2073 lines
256 KiB
HTML
2073 lines
256 KiB
HTML
<!DOCTYPE html>
|
||
<html lang="zh-CN">
|
||
<head prefix="og: http://ogp.me/ns# article: http://ogp.me/ns/article#">
|
||
<meta charset="UTF-8" />
|
||
|
||
<meta name="generator" content="Hugo 0.113.0"><meta name="theme-color" content="#fff" />
|
||
<meta name="color-scheme" content="light dark">
|
||
|
||
|
||
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
|
||
|
||
<meta name="format-detection" content="telephone=no, date=no, address=no, email=no" />
|
||
|
||
<meta http-equiv="Cache-Control" content="no-transform" />
|
||
|
||
<meta http-equiv="Cache-Control" content="no-siteapp" />
|
||
|
||
<title>《数据结构》线性表 | 飞鸿踏雪</title>
|
||
|
||
<link rel="stylesheet" href="/css/meme.min.12a3541920a798d49c1bca858f15c53090f14ce9367a34faa2bb51dd38299730.css"/>
|
||
|
||
|
||
|
||
<script src="/js/meme.min.ac2b48f322cff6a9a8036be3baf3e59e300cd9e4191997a8c3765f79de02bf8d.js"></script>
|
||
|
||
|
||
|
||
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
|
||
|
||
<link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=EB+Garamond:ital,wght@0,400;0,500;0,700;1,400;1,700&family=Noto+Serif+SC:wght@400;500;700&family=Source+Code+Pro:ital,wght@0,400;0,700;1,400;1,700&display=swap" media="print" onload="this.media='all'" />
|
||
<noscript><link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=EB+Garamond:ital,wght@0,400;0,500;0,700;1,400;1,700&family=Noto+Serif+SC:wght@400;500;700&family=Source+Code+Pro:ital,wght@0,400;0,700;1,400;1,700&display=swap" /></noscript>
|
||
|
||
<meta name="author" content="InkSoul" /><meta name="description" content="线性表的定义和操作 定义 线性表是具有相同数据类型的$n (n \leq 0 )$ 个元素的有限序列，其中$……" />
|
||
|
||
<link rel="shortcut icon" href="/favicon.ico" type="image/x-icon" />
|
||
<link rel="mask-icon" href="/icons/safari-pinned-tab.svg" color="#2a6df4" />
|
||
<link rel="apple-touch-icon" sizes="180x180" href="/icons/apple-touch-icon.png" />
|
||
<meta name="apple-mobile-web-app-capable" content="yes" />
|
||
<meta name="apple-mobile-web-app-title" content="飞鸿踏雪" />
|
||
<meta name="apple-mobile-web-app-status-bar-style" content="black" />
|
||
<meta name="mobile-web-app-capable" content="yes" />
|
||
<meta name="application-name" content="飞鸿踏雪" />
|
||
<meta name="msapplication-starturl" content="../../" />
|
||
<meta name="msapplication-TileColor" content="#fff" />
|
||
<meta name="msapplication-TileImage" content="../../icons/mstile-150x150.png" />
|
||
<link rel="manifest" href="/manifest.json" />
|
||
|
||
|
||
|
||
|
||
|
||
<link rel="canonical" href="http://www.inksoul.top/408/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E7%BA%BF%E6%80%A7%E8%A1%A8/" />
|
||
|
||
|
||
<script type="application/ld+json">
|
||
{
|
||
"@context": "https://schema.org",
|
||
"@type": "BlogPosting",
|
||
"datePublished": "2022-11-16T21:53:40+08:00",
|
||
"dateModified": "2023-06-18T21:19:01+08:00",
|
||
"url": "http://www.inksoul.top/408/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E7%BA%BF%E6%80%A7%E8%A1%A8/",
|
||
"headline": "《数据结构》线性表",
|
||
"description": "线性表的定义和操作 定义 线性表是具有相同数据类型的$n (n \\leq 0 )$ 个元素的有限序列，其中$……",
|
||
"inLanguage" : "zh-CN",
|
||
"articleSection": "408",
|
||
"wordCount": 15964 ,
|
||
"image": "http://www.inksoul.top/icons/apple-touch-icon.png",
|
||
"author": {
|
||
"@type": "Person",
|
||
"email": "qingci30@163.com",
|
||
"image": "http://www.inksoul.top/icons/apple-touch-icon.png",
|
||
"url": "http://www.inksoul.top",
|
||
"name": "InkSoul"
|
||
},
|
||
"license": "[CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/deed.zh)",
|
||
"publisher": {
|
||
"@type": "Organization",
|
||
"name": "飞鸿踏雪",
|
||
"logo": {
|
||
"@type": "ImageObject",
|
||
"url": "http://www.inksoul.top/icons/apple-touch-icon.png"
|
||
},
|
||
"url": "http://www.inksoul.top/"
|
||
},
|
||
"mainEntityOfPage": {
|
||
"@type": "WebSite",
|
||
"@id": "http://www.inksoul.top/"
|
||
}
|
||
}
|
||
</script>
|
||
|
||
|
||
|
||
|
||
|
||
|
||
<meta property="og:title" content="《数据结构》线性表" />
|
||
<meta property="og:description" content="线性表的定义和操作 定义 线性表是具有相同数据类型的$n (n \leq 0 )$ 个元素的有限序列，其中$……" />
|
||
<meta property="og:url" content="http://www.inksoul.top/408/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E7%BA%BF%E6%80%A7%E8%A1%A8/" />
|
||
<meta property="og:site_name" content="飞鸿踏雪" />
|
||
<meta property="og:locale" content="zh" /><meta property="og:image" content="http://www.inksoul.top/icons/apple-touch-icon.png" />
|
||
<meta property="og:type" content="article" />
|
||
<meta property="article:published_time" content="2022-11-16T21:53:40+08:00" />
|
||
<meta property="article:modified_time" content="2023-06-18T21:19:01+08:00" />
|
||
|
||
<meta property="article:section" content="408" />
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
</head>
|
||
|
||
<body>
|
||
<div class="container">
|
||
|
||
<header class="header">
|
||
|
||
<div class="header-wrapper">
|
||
<div class="header-inner single">
|
||
|
||
<div class="site-brand">
|
||
|
||
<a href="/" class="brand">飞鸿踏雪</a>
|
||
|
||
</div>
|
||
|
||
<nav class="nav">
|
||
<ul class="menu" id="menu">
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
<li class="menu-item"><a href="/computergraphic/"><svg class="icon computergraphic" fill="none" stroke="currentColor" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M20 7l-8-4-8 4m16 0l-8 4m8-4v10l-8 4m0-10L4 7m8 4v10M4 7v10l8 4"></path></svg><span class="menu-item-name">图形学</span></a>
|
||
</li>
|
||
|
||
|
||
|
||
<li class="menu-item"><a href="/algorithm/"><svg class="icon algorithm" fill="none" stroke="currentColor" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9.663 17h4.673M12 3v1m6.364 1.636l-.707.707M21 12h-1M4 12H3m3.343-5.657l-.707-.707m2.828 9.9a5 5 0 117.072 0l-.548.547A3.374 3.374 0 0014 18.469V19a2 2 0 11-4 0v-.531c0-.895-.356-1.754-.988-2.386l-.548-.547z"></path></svg><span class="menu-item-name">算法</span></a>
|
||
</li>
|
||
|
||
|
||
|
||
<li class="menu-item"><a href="/mathematics/"><svg class="icon mathematics" fill="none" stroke="currentColor" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 576 512"><path stroker-linecap="round" stroke-linejoin="round" stroker-width="2" d="M576 32.01c0-17.69-14.33-31.1-32-31.1l-224-.0049c-14.69 0-27.48 10-31.05 24.25L197.9 388.3L124.6 241.7C119.2 230.9 108.1 224 96 224L32 224c-17.67 0-32 14.31-32 31.1s14.33 32 32 32h44.22l103.2 206.3c5.469 10.91 16.6 17.68 28.61 17.68c1.172 0 2.323-.0576 3.495-.1826c13.31-1.469 24.31-11.06 27.56-24.06l105.9-423.8H544C561.7 64.01 576 49.7 576 32.01zM566.6 233.4c-12.5-12.5-32.75-12.5-45.25 0L480 274.8l-41.38-41.37c-12.5-12.5-32.75-12.5-45.25 0s-12.5 32.75 0 45.25l41.38 41.38l-41.38 41.38c-12.5 12.5-12.5 32.75 0 45.25C399.6 412.9 407.8 416 416 416s16.38-3.125 22.62-9.375L480 365.3l41.38 41.38C527.6 412.9 535.8 416 544 416s16.38-3.125 22.62-9.375c12.5-12.5 12.5-32.75 0-45.25l-41.38-41.38L566.6 278.6C579.1 266.1 579.1 245.9 566.6 233.4z"/></svg><span class="menu-item-name">数学</span></a>
|
||
</li>
|
||
|
||
|
||
|
||
<li class="menu-item active"><a href="/408/"><svg class="icon 408" fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 576 512"><!--! Font Awesome Pro 6.1.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2022 Fonticon 408s, Inc. --><path d="M172.1 40.16L268.1 3.76C280.9-1.089 295.1-1.089 307.9 3.76L403.9 40.16C425.6 48.41 440 69.25 440 92.52V204.7C441.3 205.1 442.6 205.5 443.9 205.1L539.9 242.4C561.6 250.6 576 271.5 576 294.7V413.9C576 436.1 562.9 456.2 542.5 465.1L446.5 507.3C432.2 513.7 415.8 513.7 401.5 507.3L288 457.5L174.5 507.3C160.2 513.7 143.8 513.7 129.5 507.3L33.46 465.1C13.13 456.2 0 436.1 0 413.9V294.7C0 271.5 14.39 250.6 36.15 242.4L132.1 205.1C133.4 205.5 134.7 205.1 136 204.7V92.52C136 69.25 150.4 48.41 172.1 40.16V40.16zM290.8 48.64C289 47.95 286.1 47.95 285.2 48.64L206.8 78.35L287.1 109.5L369.2 78.35L290.8 48.64zM392 210.6V121L309.6 152.6V241.8L392 210.6zM154.8 250.9C153 250.2 150.1 250.2 149.2 250.9L70.81 280.6L152 311.7L233.2 280.6L154.8 250.9zM173.6 455.3L256 419.1V323.2L173.6 354.8V455.3zM342.8 280.6L424 311.7L505.2 280.6L426.8 250.9C425 250.2 422.1 250.2 421.2 250.9L342.8 280.6zM528 413.9V323.2L445.6 354.8V455.3L523.2 421.2C526.1 419.9 528 417.1 528 413.9V413.9z"/></svg><span class="menu-item-name">408</span></a>
|
||
</li>
|
||
|
||
|
||
|
||
<li class="menu-item"><a href="/stuff/"><svg class="icon stuff" fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><!--! Font Awesome Pro 6.1.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2022 Fonticon stuffs, Inc. --><path d="M216 104C202.8 104 192 114.8 192 128s10.75 24 24 24c79.41 0 144 64.59 144 144C360 309.3 370.8 320 384 320s24-10.75 24-24C408 190.1 321.9 104 216 104zM224 0C206.3 0 192 14.31 192 32s14.33 32 32 32c123.5 0 224 100.5 224 224c0 17.69 14.33 32 32 32s32-14.31 32-32C512 129.2 382.8 0 224 0zM188.9 346l27.37-27.37c2.625 .625 5.059 1.506 7.809 1.506c17.75 0 31.99-14.26 31.99-32c0-17.62-14.24-32.01-31.99-32.01c-17.62 0-31.99 14.38-31.99 32.01c0 2.875 .8099 5.25 1.56 7.875L166.2 323.4L49.37 206.5c-7.25-7.25-20.12-6-24.1 3c-41.75 77.88-29.88 176.7 35.75 242.4c65.62 65.62 164.6 77.5 242.4 35.75c9.125-5 10.38-17.75 3-25L188.9 346z"/></svg><span class="menu-item-name">杂物</span></a>
|
||
</li>
|
||
|
||
|
||
|
||
<li class="menu-item"><a href="/about/"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 496 512" class="icon user-circle"><path d="M248 8C111 8 0 119 0 256s111 248 248 248 248-111 248-248S385 8 248 8zm0 96c48.6 0 88 39.4 88 88s-39.4 88-88 88-88-39.4-88-88 39.4-88 88-88zm0 344c-58.7 0-111.3-26.6-146.5-68.2 18.8-35.4 55.6-59.8 98.5-59.8 2.4 0 4.8.4 7.1 1.1 13 4.2 26.6 6.9 40.9 6.9 14.3 0 28-2.7 40.9-6.9 2.3-.7 4.7-1.1 7.1-1.1 42.9 0 79.7 24.4 98.5 59.8C359.3 421.4 306.7 448 248 448z"/></svg><span class="menu-item-name">关于</span></a>
|
||
</li>
|
||
|
||
|
||
|
||
|
||
|
||
|
||
<li class="menu-item">
|
||
<a id="theme-switcher" href="#"><span class="icon theme-icon-light">🌞</span><span class="icon theme-icon-dark">🌙</span></a>
|
||
</li>
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
</ul>
|
||
</nav>
|
||
|
||
|
||
</div>
|
||
</div>
|
||
|
||
<input type="checkbox" id="nav-toggle" aria-hidden="true" />
|
||
<label for="nav-toggle" class="nav-toggle"></label>
|
||
<label for="nav-toggle" class="nav-curtain"></label>
|
||
|
||
|
||
|
||
</header>
|
||
|
||
|
||
|
||
|
||
|
||
|
||
<main class="main single" id="main">
|
||
<div class="main-inner">
|
||
|
||
|
||
|
||
<article class="content post h-entry" data-align="justify" data-type="408" data-toc-num="true">
|
||
|
||
<h1 class="post-title p-name">《数据结构》线性表</h1>
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
<div class="post-body e-content">
|
||
<h2 id="线性表的定义和操作"><a href="#线性表的定义和操作" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>线性表的定义和操作</h2>
|
||
<h3 id="定义"><a href="#定义" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>定义</h3>
|
||
<p>线性表是具有相同数据类型的$n (n \leq 0 )$ 个元素的有限序列，其中$n$为表长，当 $n = 0$时线性表为一个空表</p>
|
||
<p>若用$L$来命名线性表，则其一般表示为 $L=(a_1,a_2,\cdots,a_i,a_(i+1),\cdots,a_n)$ 式中，$ a_1 $是唯一的“第一个”数据元素，即表头元素；$a_n$是唯一的“最后一个”数据元素，即表尾元素</p>
|
||
<p>线性表的逻辑特性：每个元素有且仅有一个直接前驱。除去最后一个元素外，每个元素有且仅有一个直接后继，这种逻辑特性即为线性表的名称由来</p>
|
||
<p>线性表的特点：</p>
|
||
<ul>
|
||
<li>表中元素个数有限</li>
|
||
<li>表中元素具有逻辑上的顺序性，表中元素有其先后次序</li>
|
||
<li>表中元素都是数据元素，每个元素都是单个元素</li>
|
||
<li>表中元素的数据类型都相同，意味着每个元素占有的存储空间相同</li>
|
||
<li>表中元素具有抽象性，仅讨论元素间的逻辑关系，而忽视元素的实际内容</li>
|
||
</ul>
|
||
<h3 id="基本操作"><a href="#基本操作" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>基本操作</h3>
|
||
<ul>
|
||
<li>InitList(&L):初始化表。构造一个空的线性表</li>
|
||
<li>Length(L):求表长。返回线性表L的长度，即L中数据元素的个数</li>
|
||
<li>LocateElem(L,e):按值查找操作。在表L中查找具有给定关键字值的元素</li>
|
||
<li>GetElem(L,i):按位查找操作。获取表L中第i个位置的元素的值</li>
|
||
<li>ListInsert(&L,i,&e):插入操作。在表L中第i个位置插入指定元素e</li>
|
||
<li>ListDelete(&L,i,&e):删除操作。删除表L中第i个位置的元素，并用e返回删除元素的值</li>
|
||
<li>PrintList(L):输出操作。按前后顺序输出线性表L的所有元素值</li>
|
||
<li>Empty(L):判空操作。若L为空表，则返回true</li>
|
||
<li>DestroyList:销毁操作。销毁线性表，并释放线性表L所占用的内存空间</li>
|
||
</ul>
|
||
<h2 id="线性表的顺序表示顺序表"><a href="#线性表的顺序表示顺序表" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>线性表的顺序表示（顺序表）</h2>
|
||
<h3 id="定义-1"><a href="#定义-1" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>定义</h3>
|
||
<p>顺序表，即线性表的顺序存储。是用一组地址连续的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理位置上也相邻。</p>
|
||
<p>第一个元素存储在线性表的起始位置，第i个元素的存储位置后面紧接着存储的是$i + 1$个元素，称$i$为元素$a_i$在线性表中的位序，因此可见，顺序表的特点是表中元素的逻辑顺序与其物理顺序相同</p>
|
||
<p>假设线性表L存储的起始位置为LOC(A),sizeof(ElemType)为每个数据元素所占用存储空间的大小，可得该表对应的顺序存储如下</p>
|
||
<div class="table-container"><table>
|
||
<thead>
|
||
<tr>
|
||
<th style="text-align:center">数组下标</th>
|
||
<th style="text-align:center">顺序表</th>
|
||
<th style="text-align:center">内存地址</th>
|
||
</tr>
|
||
</thead>
|
||
<tbody>
|
||
<tr>
|
||
<td style="text-align:center">0</td>
|
||
<td style="text-align:center">$a_1$</td>
|
||
<td style="text-align:center">LOC(A)</td>
|
||
</tr>
|
||
<tr>
|
||
<td style="text-align:center">1</td>
|
||
<td style="text-align:center">$a_2$</td>
|
||
<td style="text-align:center">LOC(A) + sizeof(ElemType)</td>
|
||
</tr>
|
||
<tr>
|
||
<td style="text-align:center">i-1</td>
|
||
<td style="text-align:center">$a_i$</td>
|
||
<td style="text-align:center">LOC(A) + (i-1)$\times$sizeof(ElemType)</td>
|
||
</tr>
|
||
<tr>
|
||
<td style="text-align:center">n-1</td>
|
||
<td style="text-align:center">$a_n$</td>
|
||
<td style="text-align:center">LOC(A) + (n-1)$\times$sizeof(ElemType)</td>
|
||
</tr>
|
||
<tr>
|
||
<td style="text-align:center">MaxSize - 1</td>
|
||
<td style="text-align:center">$\cdots$</td>
|
||
<td style="text-align:center">LOC(A) + (MaxSize - 1)$\times$sizeof(ElemType)</td>
|
||
</tr>
|
||
</tbody>
|
||
</table></div>
|
||
<p>每个数据元素的存储位置和线性表的起始位置相差一个和该数据元素的位序成正比的常数，因此，线性表中的任一数据元素都可以随机存取，所以线性表的顺序存储结构是一种随机存取的存储结构</p>
|
||
<ul>
|
||
<li>Attention : 线性表中元素的位序从1开始，而数组中元素下标是从0开始的</li>
|
||
</ul>
|
||
<p>假定线性表的元素类型为ElemType，则线性表的顺序存储类型可描述为：</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt">1
|
||
</span><span class="lnt">2
|
||
</span><span class="lnt">3
|
||
</span><span class="lnt">4
|
||
</span><span class="lnt">5
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-C++" data-lang="C++"><span class="line"><span class="cl"><span class="cp">#define MaxSize 50 </span><span class="c1">//定义线性表最大长度
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="k">typedef</span> <span class="k">struct</span><span class="p">{</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">ElemType</span> <span class="n">data</span><span class="p">[</span><span class="n">MaxSize</span><span class="p">];</span> <span class="c1">//顺序表的元素
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="kt">int</span> <span class="n">length</span><span class="p">;</span> <span class="c1">//顺序表的当前长度
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">}</span><span class="n">SqList</span><span class="p">;</span> <span class="c1">//顺序表的类型定义
|
||
</span></span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><p>一组数组可以是静态分配的，也可以是动态分配的</p>
|
||
<ol>
|
||
<li>静态分配时，由于数组的大小和空间已经固定，一旦空间占满，再加入新的数据就会产生溢出，进而导致程序崩溃</li>
|
||
<li>动态分配时，存储数组的空间是在程序执行过程中通过动态存储分配语句分配的，一旦数据空间占满就另外开辟一块更大的存储空间用以替换原来的存储空间，从而扩充存储数组空间的目的，不需要为线性表一次性划分所有空间</li>
|
||
</ol>
|
||
<p>动态分配的顺序存储类型定义：</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt">1
|
||
</span><span class="lnt">2
|
||
</span><span class="lnt">3
|
||
</span><span class="lnt">4
|
||
</span><span class="lnt">5
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c++" data-lang="c++"><span class="line"><span class="cl"><span class="cp">#define InitSize 100 </span><span class="c1">//表长度的初始定义
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="k">typedef</span> <span class="k">struct</span><span class="p">{</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">ElemType</span> <span class="o">*</span><span class="n">data</span><span class="p">;</span> <span class="c1">//指示动态分配数组的指针
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="kt">int</span> <span class="n">MaxSize</span><span class="p">,</span><span class="n">length</span><span class="p">;</span> <span class="c1">//数组的最大容量和当前个数
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">}</span><span class="n">SeqList</span><span class="p">;</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><p>C的初始动态分配语句为：</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt">1
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="n">L</span><span class="p">.</span><span class="n">data</span> <span class="o">=</span> <span class="p">(</span><span class="n">ElemType</span><span class="o">*</span><span class="p">)</span><span class="nf">malloc</span><span class="p">(</span><span class="k">sizeof</span><span class="p">(</span><span class="n">ElemType</span><span class="p">)</span><span class="o">*</span><span class="n">InitSize</span><span class="p">);</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><p>C++的初始动态分配语句为：</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt">1
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-C++" data-lang="C++"><span class="line"><span class="cl"><span class="n">L</span><span class="p">.</span><span class="n">data</span> <span class="o">=</span> <span class="k">new</span> <span class="n">ElemType</span><span class="p">[</span><span class="n">InitSize</span><span class="p">];</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><ul>
|
||
<li>Attention : 动态分配并非链式存储，同样属于顺序存储结构，物理结构无变化，依然为随机存储方式，只是分配的空间大小可以在运行时动态决定</li>
|
||
<li>顺序表主要特点是随机访问，即通过首地址和元素序号可以在时间$O(1)$内找到指定元素</li>
|
||
<li>顺序表存储密度相对更高，结点只存储数据元素</li>
|
||
<li>顺序表逻辑上相邻的元素物理上也相邻，所以在插入和删除时需要移动大量元素</li>
|
||
</ul>
|
||
<h3 id="顺序表基本操作的实现"><a href="#顺序表基本操作的实现" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>顺序表基本操作的实现</h3>
|
||
<h4 id="插入"><a href="#插入" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>插入</h4>
|
||
<p>在顺序表L的第$i(1<=i<=L.length+1)$个位置插入新元素e。若i的输入不合法，则返回false，表示插入失败;否则，将第i个元素及其以后的所有元素依次往后移动一个位置，腾出一个位置插入新元素e，顺序表长度+1，插入成功，返回true</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
|
||
</span><span class="lnt"> 2
|
||
</span><span class="lnt"> 3
|
||
</span><span class="lnt"> 4
|
||
</span><span class="lnt"> 5
|
||
</span><span class="lnt"> 6
|
||
</span><span class="lnt"> 7
|
||
</span><span class="lnt"> 8
|
||
</span><span class="lnt"> 9
|
||
</span><span class="lnt">10
|
||
</span><span class="lnt">11
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c++" data-lang="c++"><span class="line"><span class="cl"><span class="kt">bool</span> <span class="nf">ListInsert</span><span class="p">(</span><span class="n">SqList</span> <span class="o">&</span><span class="n">L</span><span class="p">,</span><span class="kt">int</span> <span class="n">i</span><span class="p">,</span><span class="n">ElemType</span> <span class="n">e</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">if</span><span class="p">(</span><span class="n">i</span><span class="o"><</span><span class="mi">1</span><span class="o">||</span><span class="n">i</span><span class="o">></span><span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="o">+</span><span class="mi">1</span><span class="p">)</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nb">false</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">if</span><span class="p">(</span><span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="o">>=</span><span class="n">MaxSize</span><span class="p">)</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nb">false</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">for</span><span class="p">(</span><span class="kt">int</span> <span class="n">j</span><span class="o">=</span><span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="p">;</span><span class="n">j</span><span class="o">>=</span><span class="n">i</span><span class="p">;</span><span class="n">j</span><span class="o">--</span><span class="p">)</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">j</span><span class="p">]</span><span class="o">=</span><span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">j</span><span class="o">-</span><span class="mi">1</span><span class="p">];</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">i</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span><span class="o">=</span><span class="n">e</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="o">++</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nb">true</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"><span class="p">}</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><ul>
|
||
<li>最好情况：在表尾插入（即$i=n+1$），元素后移语句不执行，时间复杂度为$O(1)$</li>
|
||
<li>最坏情况：在表头插入（即$i=1$），元素后移语句将执行n次，时间复杂度为$O(n)$</li>
|
||
<li>平均情况：假设$p_i(p_i=1/(n+1))$是在第$i$个位置上插入一个结点的概率，则在长度为$n$的线性表中插入一个结点时，所需移动结点的平均次数为</li>
|
||
</ul>
|
||
<p>$$
|
||
\sum_{i=1}^{n+1} p_i(n-i+1) = \sum_{i=1}^{n+1} \frac{1}{n+1}(n-i+1)=\frac{1}{n+1}\sum_{i=1}^{n+1}(n-i+1)=\frac{1}{n+1}\frac{n(n+1)}{2}=\frac{n}{2}
|
||
$$</p>
|
||
<p>由此可得，线性表插入算法的平均时间复杂度为$O(n)$</p>
|
||
<h4 id="删除"><a href="#删除" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>删除</h4>
|
||
<p>删除顺序表L中第$i$个$(1<=i<=L.length)$个位置的元素，用引用变量e返回。若i的输入不合法，则返回false;否则，将被删元素赋给引用变量e，并将第$i+1$个元素及其后的所有元素依次往前移动一个位置，返回true。</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt">1
|
||
</span><span class="lnt">2
|
||
</span><span class="lnt">3
|
||
</span><span class="lnt">4
|
||
</span><span class="lnt">5
|
||
</span><span class="lnt">6
|
||
</span><span class="lnt">7
|
||
</span><span class="lnt">8
|
||
</span><span class="lnt">9
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c++" data-lang="c++"><span class="line"><span class="cl"><span class="kt">bool</span> <span class="nf">ListDelete</span><span class="p">(</span><span class="n">SqList</span> <span class="o">&</span><span class="n">L</span><span class="p">,</span><span class="kt">int</span> <span class="n">i</span><span class="p">,</span><span class="n">Elemtype</span> <span class="o">&</span><span class="n">e</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">if</span><span class="p">(</span><span class="n">i</span><span class="o"><</span><span class="mi">1</span><span class="o">||</span><span class="n">i</span><span class="o">></span><span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="p">)</span> <span class="c1">//判断i的范围是否有效
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">return</span> <span class="nb">false</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">e</span><span class="o">=</span><span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">i</span><span class="o">-</span><span class="mi">1</span><span class="p">];</span> <span class="c1">//将被删除的元素赋值给e
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">for</span><span class="p">(</span><span class="kt">int</span> <span class="n">j</span><span class="o">=</span><span class="n">i</span><span class="p">;</span><span class="n">j</span><span class="o"><</span><span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="p">;</span><span class="n">j</span><span class="o">++</span><span class="p">)</span><span class="c1">//将第i个位置后的元素后移
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">j</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span><span class="o">=</span><span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">j</span><span class="p">];</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="o">--</span><span class="p">;</span> <span class="c1">//线性表长度减一
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">return</span> <span class="nb">true</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"><span class="p">}</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><ul>
|
||
<li>最好情况：删除表尾元素(即$i=n$),无须移动元素，时间复杂度为$O(1)$</li>
|
||
<li>最坏情况：删除表头元素(即$i=1$),需移动除表头元素外的所有元素，时间复杂度为$O(n)$</li>
|
||
<li>平均情况：假设$p_i(p_i = 1/n)$是删除第i个位置上结点的概率，则在长度为n的线性表中删除一个结点时，所需移动结点的平均次数为</li>
|
||
</ul>
|
||
<p>$$
|
||
\sum_{i=1}^{n} p_i(n-i)=\sum_{i=1}^{n} \frac{1}{n}(n-i) = \frac{1}{n}\sum_{i=1}^{n}(n-i) = \frac{1}{n}\frac{n(n-1)}{2} = \frac{n-1}{2}
|
||
$$</p>
|
||
<p>可见线性表删除算法的平均时间复杂度为$O(n)$且顺序表中插入和删除操作的时间主要耗费在移动元素上，而移动元素的个数取决于插入和删除元素的位置。</p>
|
||
<h4 id="按值查找顺序查找"><a href="#按值查找顺序查找" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>按值查找(顺序查找)</h4>
|
||
<p>在顺序表L中查找第一个元素值等于e的元素，并返回其位序</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt">1
|
||
</span><span class="lnt">2
|
||
</span><span class="lnt">3
|
||
</span><span class="lnt">4
|
||
</span><span class="lnt">5
|
||
</span><span class="lnt">6
|
||
</span><span class="lnt">7
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c++" data-lang="c++"><span class="line"><span class="cl"><span class="kt">int</span> <span class="nf">LocateElem</span><span class="p">(</span><span class="n">SqList</span> <span class="n">L</span><span class="p">,</span><span class="n">ElemType</span> <span class="n">e</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="kt">int</span> <span class="n">i</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">for</span><span class="p">(</span><span class="n">i</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span><span class="n">i</span><span class="o"><</span><span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="p">;</span><span class="n">i</span><span class="o">++</span><span class="p">)</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">if</span><span class="p">(</span><span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">==</span><span class="n">e</span><span class="p">)</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">;</span> <span class="c1">//下标为i的元素值等于e，返回其位序i+1
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span> <span class="c1">//退出循环，说明查找失败
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">}</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><ul>
|
||
<li>最好情况：查找的元素就在表头，仅需比较一次，时间复杂度为$O(1)$</li>
|
||
<li>最坏情况：查找的元素在表尾或不存在时，需要比较n次，时间复杂度为$O(n)$</li>
|
||
<li>平均情况：假设$p_i(p_i=1/n)$是查找的元素在第$i(l<=i<=L.length)$个位置上的概率，则在长度为n的线性表中查找值为e的元素所需比较的平均次数为</li>
|
||
</ul>
|
||
<p>$$
|
||
\sum_{i=1}^{n}p_i \times i = \sum_{i=1}^{n} \frac{1}{n} \times i = \frac{1}{n} \frac{n(n+1)}{2} = \frac{n+1}{2}
|
||
$$</p>
|
||
<p>因此线性表按值查找算法的平均时间复杂度为$O(n)$</p>
|
||
<h3 id="一些练习"><a href="#一些练习" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>一些练习</h3>
|
||
<ol>
|
||
<li>从顺序表中删除具有最小值的元素(假设唯一)并由函数返回被删元素的值。空出的位置由最后一个元素填补，若顺序表为空，则显示出错信息并退出运行</li>
|
||
</ol>
|
||
<p>算法思想：搜索整个顺序表，查找最小值元素并记住其位置，搜索结束后用最后一个元素填补空出的原最小值元素的位置</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
|
||
</span><span class="lnt"> 2
|
||
</span><span class="lnt"> 3
|
||
</span><span class="lnt"> 4
|
||
</span><span class="lnt"> 5
|
||
</span><span class="lnt"> 6
|
||
</span><span class="lnt"> 7
|
||
</span><span class="lnt"> 8
|
||
</span><span class="lnt"> 9
|
||
</span><span class="lnt">10
|
||
</span><span class="lnt">11
|
||
</span><span class="lnt">12
|
||
</span><span class="lnt">13
|
||
</span><span class="lnt">14
|
||
</span><span class="lnt">15
|
||
</span><span class="lnt">16
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c++" data-lang="c++"><span class="line"><span class="cl"><span class="kt">bool</span> <span class="nf">Del_Min</span><span class="p">(</span><span class="n">sqList</span> <span class="o">&</span><span class="n">L</span><span class="p">,</span><span class="n">ElemType</span> <span class="o">&</span><span class="n">value</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="c1">//删除顺序表L中最小值元素结点，并通过引用型参数value返回其值
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="c1">//若删除成功，则返回true，否则返回false
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">if</span><span class="p">(</span><span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="o">==</span><span class="mi">0</span><span class="p">)</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nb">false</span><span class="p">;</span><span class="c1">//表空，中止操作
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">value</span><span class="o">=</span><span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="mi">0</span><span class="p">];</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="kt">int</span> <span class="n">pos</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span> <span class="c1">//假定0号元素数值最小
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">for</span><span class="p">(</span><span class="kt">int</span> <span class="n">i</span><span class="o">=</span><span class="mi">1</span><span class="p">;</span><span class="n">i</span><span class="o"><</span><span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="p">;</span><span class="n">i</span><span class="o">++</span><span class="p">)</span> <span class="c1">//循环，寻找具有最小值的元素
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">if</span><span class="p">(</span><span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o"><</span><span class="n">value</span><span class="p">){</span> <span class="c1">//让value记忆当前具有最小值的元素
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">value</span><span class="o">=</span><span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">i</span><span class="p">];</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">pos</span><span class="o">=</span><span class="n">i</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">pos</span><span class="p">]</span><span class="o">=</span><span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="o">-</span><span class="mi">1</span><span class="p">];</span> <span class="c1">//让最后一个元素填补空缺的位置
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="o">--</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nb">true</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"><span class="p">}</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><ol start="2">
|
||
<li>设计一个高效算法，将顺序表L的所有元素逆置，要求算法的空间复杂度为$O(1)$</li>
|
||
</ol>
|
||
<p>算法思想：扫描顺序表L的前半部分元素，对于元素L.data<a href="0%3C=i%3CL.length/2">i</a>,将其与后半部分的对应元素L.data[L.length-i-1]进行交换</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt">1
|
||
</span><span class="lnt">2
|
||
</span><span class="lnt">3
|
||
</span><span class="lnt">4
|
||
</span><span class="lnt">5
|
||
</span><span class="lnt">6
|
||
</span><span class="lnt">7
|
||
</span><span class="lnt">8
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c++" data-lang="c++"><span class="line"><span class="cl"><span class="kt">void</span> <span class="nf">Reverse</span><span class="p">(</span><span class="n">Sqlist</span> <span class="o">&</span><span class="n">L</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">Elemtype</span> <span class="n">temp</span><span class="p">;</span> <span class="c1">//辅助变量
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">for</span><span class="p">(</span><span class="n">i</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span><span class="n">i</span><span class="o"><</span><span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="o">/</span><span class="mi">2</span><span class="p">;</span><span class="n">i</span><span class="o">++</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">temp</span><span class="o">=</span><span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">i</span><span class="p">];</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">=</span><span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="o">-</span><span class="n">i</span><span class="o">-</span><span class="mi">1</span><span class="p">];</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="o">-</span><span class="n">i</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span><span class="o">=</span><span class="n">temp</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"><span class="p">}</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><ol start="3">
|
||
<li>对长度为n的顺序表L，编写一个时间复杂度为$O(n)$、空间复杂度为$O(1)$的算法，该算法删除线性表中所有值为x的数据元素</li>
|
||
</ol>
|
||
<p>解法一：用k记录顺序表L中不等于x的元素个数(即需要保存的元素个数)，边扫描L边统计k，并将不等于x的元素向前移动k个位置，最后修改L的长度</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt">1
|
||
</span><span class="lnt">2
|
||
</span><span class="lnt">3
|
||
</span><span class="lnt">4
|
||
</span><span class="lnt">5
|
||
</span><span class="lnt">6
|
||
</span><span class="lnt">7
|
||
</span><span class="lnt">8
|
||
</span><span class="lnt">9
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c++" data-lang="c++"><span class="line"><span class="cl"><span class="kt">void</span> <span class="nf">del_x_1</span><span class="p">(</span><span class="n">Sqlist</span> <span class="o">&</span><span class="n">L</span><span class="p">,</span><span class="n">Elemtype</span> <span class="n">x</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="kt">int</span> <span class="n">k</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span> <span class="c1">//记录值不等于x的元素个数
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">for</span><span class="p">(</span><span class="n">i</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span><span class="n">i</span><span class="o"><</span><span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="p">;</span><span class="n">i</span><span class="o">++</span><span class="p">)</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">if</span><span class="p">(</span><span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">!=</span><span class="n">x</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">k</span><span class="p">]</span><span class="o">=</span><span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">i</span><span class="p">];</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">k</span><span class="o">++</span><span class="p">;</span> <span class="c1">//不等于x的元素增一
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="o">=</span><span class="n">k</span><span class="p">;</span> <span class="c1">//顺序表L的长度等于k
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">}</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><p>解法二：用k记录顺序表L中等于x的元素个数，边扫描L边统计k，并将不等于x的元素前移k个位置，最后修改L的长度</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
|
||
</span><span class="lnt"> 2
|
||
</span><span class="lnt"> 3
|
||
</span><span class="lnt"> 4
|
||
</span><span class="lnt"> 5
|
||
</span><span class="lnt"> 6
|
||
</span><span class="lnt"> 7
|
||
</span><span class="lnt"> 8
|
||
</span><span class="lnt"> 9
|
||
</span><span class="lnt">10
|
||
</span><span class="lnt">11
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c++" data-lang="c++"><span class="line"><span class="cl"><span class="kt">void</span> <span class="nf">del_x_2</span><span class="p">(</span><span class="n">Sqlist</span> <span class="o">&</span><span class="n">L</span><span class="p">,</span><span class="n">Elemtype</span> <span class="n">x</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="kt">int</span> <span class="n">k</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span><span class="n">i</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">while</span><span class="p">(</span><span class="n">i</span><span class="o"><</span><span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">if</span><span class="p">(</span><span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">==</span><span class="n">x</span><span class="p">)</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">k</span><span class="o">++</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">else</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">i</span><span class="o">-</span><span class="n">k</span><span class="p">]</span><span class="o">=</span><span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">i</span><span class="p">];</span> <span class="c1">//当前元素前移k个位置
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">i</span><span class="o">++</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="o">=</span><span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="o">-</span><span class="n">k</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"><span class="p">}</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><ol start="4">
|
||
<li>从有序顺序表中删除其值在给定值s与t之间(包含s和t，要求s<t)的所有元素，若s或t不合理或顺序表为空，则显示出错信息退出运行</li>
|
||
</ol>
|
||
<p>算法思想：因为是有序表，所以删除的部分必定是一个整体，先寻找值大于等于s的一个元素(第一个删除的元素)，然后寻找值大于t的第一个元素(最后一个删除的元素的下一个元素)，要将这段元素删除，只需将后面的元素前移</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
|
||
</span><span class="lnt"> 2
|
||
</span><span class="lnt"> 3
|
||
</span><span class="lnt"> 4
|
||
</span><span class="lnt"> 5
|
||
</span><span class="lnt"> 6
|
||
</span><span class="lnt"> 7
|
||
</span><span class="lnt"> 8
|
||
</span><span class="lnt"> 9
|
||
</span><span class="lnt">10
|
||
</span><span class="lnt">11
|
||
</span><span class="lnt">12
|
||
</span><span class="lnt">13
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c++" data-lang="c++"><span class="line"><span class="cl"><span class="kt">bool</span> <span class="nf">del_s_t2</span><span class="p">(</span><span class="n">SqList</span> <span class="o">&</span><span class="n">L</span><span class="p">,</span><span class="n">ElemType</span> <span class="n">s</span><span class="p">,</span><span class="n">ElemType</span> <span class="n">t</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="kt">int</span> <span class="n">i</span><span class="p">,</span><span class="n">j</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">if</span><span class="p">(</span><span class="n">s</span><span class="o">>=</span><span class="n">t</span><span class="o">||</span><span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="o">==</span><span class="mi">0</span><span class="p">)</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nb">false</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">for</span><span class="p">(</span><span class="n">i</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span><span class="n">i</span><span class="o"><=</span><span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="o">&&</span><span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o"><</span><span class="n">s</span><span class="p">;</span><span class="n">i</span><span class="o">++</span><span class="p">);</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">if</span><span class="p">(</span><span class="n">i</span><span class="o">>=</span><span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="p">)</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nb">false</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">for</span><span class="p">(</span><span class="n">j</span><span class="o">=</span><span class="n">i</span><span class="p">;</span><span class="n">j</span><span class="o"><</span><span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="o">&&</span><span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">j</span><span class="p">]</span><span class="o"><=</span><span class="n">t</span><span class="p">;</span><span class="n">j</span><span class="o">++</span><span class="p">);</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">for</span><span class="p">(</span><span class="n">j</span><span class="o"><</span><span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="p">;</span><span class="n">i</span><span class="o">++</span><span class="p">;</span><span class="n">j</span><span class="o">++</span><span class="p">)</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">=</span><span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">j</span><span class="p">];</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="o">=</span><span class="n">i</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nb">true</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"><span class="p">}</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><ol start="5">
|
||
<li>从顺序表中删除其值在给定值s与t之间(包含s和t，s<t)的所有元素，若s或t不合理或顺序表为空，则显示出错信息并退出运行</li>
|
||
</ol>
|
||
<p>算法思想：从前向后扫描顺序表L，用k记录下元素值在s到t之间元素的个数(初始时k=0)。对于当前扫描的元素，若起值不在s到t之间，则前移k个位置，否则执行k++。由于这样每个不在s到t之间的元素仅移动一次，因此算法的效率高</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
|
||
</span><span class="lnt"> 2
|
||
</span><span class="lnt"> 3
|
||
</span><span class="lnt"> 4
|
||
</span><span class="lnt"> 5
|
||
</span><span class="lnt"> 6
|
||
</span><span class="lnt"> 7
|
||
</span><span class="lnt"> 8
|
||
</span><span class="lnt"> 9
|
||
</span><span class="lnt">10
|
||
</span><span class="lnt">11
|
||
</span><span class="lnt">12
|
||
</span><span class="lnt">13
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c++" data-lang="c++"><span class="line"><span class="cl"><span class="kt">bool</span> <span class="nf">Del_s_t</span><span class="p">(</span><span class="n">SqList</span> <span class="o">&</span><span class="n">L</span><span class="p">,</span><span class="n">ElemType</span> <span class="n">s</span><span class="p">,</span><span class="n">ElemType</span> <span class="n">t</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="kt">int</span> <span class="n">i</span><span class="p">,</span><span class="n">k</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">if</span><span class="p">(</span><span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="o">==</span><span class="mi">0</span><span class="o">||</span><span class="n">s</span><span class="o">>=</span><span class="n">t</span><span class="p">)</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nb">false</span><span class="p">;</span> <span class="c1">//线性表为空或s，t不合法
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">for</span><span class="p">(</span><span class="n">i</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span><span class="n">i</span><span class="o"><</span><span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="p">;</span><span class="n">i</span><span class="o">++</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">if</span><span class="p">(</span><span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">>=</span><span class="n">s</span><span class="o">&&</span><span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o"><=</span><span class="n">t</span><span class="p">)</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">k</span><span class="o">++</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">else</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">i</span><span class="o">-</span><span class="n">k</span><span class="p">]</span><span class="o">=</span><span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">i</span><span class="p">];</span> <span class="c1">//当前元素前移k个位置
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="o">-=</span><span class="n">k</span><span class="p">;</span> <span class="c1">//长度减小
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">return</span> <span class="nb">true</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"><span class="p">}</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><ol start="6">
|
||
<li>从有序顺序表中删除所有其值重复的元素，使表中所有元素的值均不同</li>
|
||
</ol>
|
||
<p>算法思想：有序顺序表，因此值相同的元素一定在连续的位置上，用类似于直接插入排序的思想，初始时将第一个元素视为非重复的有序表，之后依次判断后面的元素是否与前面非重复有序表的最后一个元素相同，若相同，则继续向后判断，若不同，则插入前面的非重复有序表的最后，知道判断到表为为止</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
|
||
</span><span class="lnt"> 2
|
||
</span><span class="lnt"> 3
|
||
</span><span class="lnt"> 4
|
||
</span><span class="lnt"> 5
|
||
</span><span class="lnt"> 6
|
||
</span><span class="lnt"> 7
|
||
</span><span class="lnt"> 8
|
||
</span><span class="lnt"> 9
|
||
</span><span class="lnt">10
|
||
</span><span class="lnt">11
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c++" data-lang="c++"><span class="line"><span class="cl"><span class="kt">bool</span> <span class="nf">Delete_Same</span><span class="p">(</span><span class="n">SeqList</span><span class="o">&</span> <span class="n">L</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">if</span><span class="p">(</span><span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="o">==</span><span class="mi">0</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nb">false</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="kt">int</span> <span class="n">i</span><span class="p">,</span><span class="n">j</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">for</span><span class="p">(</span><span class="n">i</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span><span class="n">j</span><span class="o">=</span><span class="mi">1</span><span class="p">;</span><span class="n">j</span><span class="o"><</span><span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="p">;</span><span class="n">j</span><span class="o">++</span><span class="p">)</span> <span class="c1">//i存储第一个不相同的元素，j为工作指针
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">if</span><span class="p">(</span><span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">!=</span><span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">j</span><span class="p">])</span> <span class="c1">//查找下一个与上个元素值不同的元素
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="o">++</span><span class="n">i</span><span class="p">]</span><span class="o">=</span><span class="n">L</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">j</span><span class="p">];</span><span class="c1">//查找到后，将元素前移
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">L</span><span class="p">.</span><span class="n">length</span><span class="o">=</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nb">true</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"><span class="p">}</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><ol start="7">
|
||
<li>将两个有序顺序表合并为一个新的有序顺序表，并由函数返回结果顺序表</li>
|
||
</ol>
|
||
<p>算法思想：首先，按顺序不断取下两个顺序表表头较小的结点存入新的顺序表中，然后，看哪个表还有剩余，将剩下的部分加到新的顺序表后面</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
|
||
</span><span class="lnt"> 2
|
||
</span><span class="lnt"> 3
|
||
</span><span class="lnt"> 4
|
||
</span><span class="lnt"> 5
|
||
</span><span class="lnt"> 6
|
||
</span><span class="lnt"> 7
|
||
</span><span class="lnt"> 8
|
||
</span><span class="lnt"> 9
|
||
</span><span class="lnt">10
|
||
</span><span class="lnt">11
|
||
</span><span class="lnt">12
|
||
</span><span class="lnt">13
|
||
</span><span class="lnt">14
|
||
</span><span class="lnt">15
|
||
</span><span class="lnt">16
|
||
</span><span class="lnt">17
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c++" data-lang="c++"><span class="line"><span class="cl"><span class="kt">bool</span> <span class="nf">Merge</span><span class="p">(</span><span class="n">SqList</span> <span class="n">A</span><span class="p">,</span><span class="n">SeqList</span> <span class="n">B</span><span class="p">,</span><span class="n">SeqList</span> <span class="o">&</span><span class="n">C</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">if</span><span class="p">(</span><span class="n">A</span><span class="p">.</span><span class="n">length</span><span class="o">+</span><span class="n">B</span><span class="p">.</span><span class="n">length</span><span class="o">></span><span class="n">C</span><span class="p">.</span><span class="n">maxSize</span><span class="p">)</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nb">false</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="kt">int</span> <span class="n">i</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span><span class="n">j</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span><span class="n">k</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">while</span><span class="p">(</span><span class="n">i</span><span class="o"><</span><span class="n">A</span><span class="p">.</span><span class="n">length</span><span class="o">&&</span><span class="n">B</span><span class="p">.</span><span class="n">length</span><span class="p">){</span> <span class="c1">//循环，两两比较，小者存入结果表
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">if</span><span class="p">(</span><span class="n">A</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o"><=</span><span class="n">B</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">j</span><span class="p">]);</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">C</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">k</span><span class="o">++</span><span class="p">]</span><span class="o">=</span><span class="n">A</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">i</span><span class="o">++</span><span class="p">];</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">else</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">C</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">k</span><span class="o">++</span><span class="p">]</span><span class="o">=</span><span class="n">B</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">k</span><span class="o">++</span><span class="p">];</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">while</span><span class="p">(</span><span class="n">i</span><span class="o"><</span><span class="n">A</span><span class="p">.</span><span class="n">length</span><span class="p">)</span> <span class="c1">//还剩一个没有比较完的顺序表
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">C</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">k</span><span class="o">++</span><span class="p">]</span><span class="o">=</span><span class="n">A</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">i</span><span class="o">++</span><span class="p">];</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">while</span><span class="p">(</span><span class="n">j</span><span class="o"><</span><span class="n">B</span><span class="p">.</span><span class="n">length</span><span class="p">)</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">C</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">k</span><span class="o">++</span><span class="p">]</span><span class="o">=</span><span class="n">B</span><span class="p">.</span><span class="n">data</span><span class="p">[</span><span class="n">j</span><span class="o">++</span><span class="p">];</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">C</span><span class="p">.</span><span class="n">length</span><span class="o">=</span><span class="n">k</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nb">true</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"><span class="p">}</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><ol start="8">
|
||
<li>已知在一位数组A[m+n]中一次存放两个线性表$(a_1,a_2,a_3,\cdots,a_m)$和$(b_1,b_2,b_3,\cdots,b_n)$。试编写一个函数，将数组中两个顺序表的位置互换，即将$(a_1,a_2,a_3,\cdots,\a_m$放在$(b_1,b_2,b_3,\cdots,b_n)$后面</li>
|
||
</ol>
|
||
<p>算法思想：先将数组A[m+n]中的全部元素$(a_1,a_2,a_3,\cdots,a_m,b_1,b_2,b_3,\cdots,b_n)$原地逆置为$(b_n,b_{n-1},b_{n-2},\cdots,b_1,a_m,a_{m-1},a_{m-2},\cdots,a_1)$,再对前n个元素和后m个元素分别使用逆置算法，即可得到$(b_1,b_2,b_3,\cdots,b_n,a_1,a_2,a_3,\cdots,a_m)$,从而实现顺序表的位置互换</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
|
||
</span><span class="lnt"> 2
|
||
</span><span class="lnt"> 3
|
||
</span><span class="lnt"> 4
|
||
</span><span class="lnt"> 5
|
||
</span><span class="lnt"> 6
|
||
</span><span class="lnt"> 7
|
||
</span><span class="lnt"> 8
|
||
</span><span class="lnt"> 9
|
||
</span><span class="lnt">10
|
||
</span><span class="lnt">11
|
||
</span><span class="lnt">12
|
||
</span><span class="lnt">13
|
||
</span><span class="lnt">14
|
||
</span><span class="lnt">15
|
||
</span><span class="lnt">16
|
||
</span><span class="lnt">17
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c++" data-lang="c++"><span class="line"><span class="cl"><span class="k">typedef</span> <span class="kt">int</span> <span class="n">DataType</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"><span class="kt">void</span> <span class="nf">Reverse</span><span class="p">(</span><span class="n">DataType</span> <span class="n">A</span><span class="p">[],</span><span class="kt">int</span> <span class="n">left</span><span class="p">,</span><span class="kt">int</span> <span class="n">right</span><span class="p">,</span><span class="kt">int</span> <span class="n">arraySize</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">if</span><span class="p">(</span><span class="n">left</span><span class="o">>=</span><span class="n">right</span><span class="o">||</span><span class="n">right</span><span class="o">>=</span><span class="n">arraySize</span><span class="p">)</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="kt">int</span> <span class="n">mid</span><span class="o">=</span><span class="p">(</span><span class="n">left</span><span class="o">+</span><span class="n">right</span><span class="p">)</span><span class="o">/</span><span class="mi">2</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">for</span><span class="p">(</span><span class="kt">int</span> <span class="n">i</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span><span class="n">i</span><span class="o"><=</span><span class="n">mid</span><span class="o">-</span><span class="n">left</span><span class="p">;</span><span class="n">i</span><span class="o">++</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">Datatype</span> <span class="n">temp</span> <span class="o">=</span> <span class="n">A</span><span class="p">[</span><span class="n">left</span><span class="o">+</span><span class="n">i</span><span class="p">];</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">A</span><span class="p">[</span><span class="n">left</span><span class="o">+</span><span class="n">i</span><span class="p">]</span><span class="o">=</span><span class="n">A</span><span class="p">[</span><span class="n">right</span><span class="o">-</span><span class="n">i</span><span class="p">];</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">A</span><span class="p">[</span><span class="n">right</span><span class="o">-</span><span class="n">i</span><span class="p">]</span><span class="o">=</span><span class="n">temp</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"><span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl">
|
||
</span></span><span class="line"><span class="cl"><span class="kt">void</span> <span class="nf">Exchange</span><span class="p">(</span><span class="n">DataType</span> <span class="n">A</span><span class="p">[],</span><span class="kt">int</span> <span class="n">m</span><span class="p">,</span><span class="kt">int</span> <span class="n">n</span><span class="p">,</span><span class="kt">int</span> <span class="n">arraySize</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">Reverse</span><span class="p">(</span><span class="n">A</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="n">m</span><span class="o">+</span><span class="n">n</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span><span class="n">arraySize</span><span class="p">);</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">Reverse</span><span class="p">(</span><span class="n">A</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="n">n</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span><span class="n">arraySize</span><span class="p">);</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">Reverse</span><span class="p">(</span><span class="n">A</span><span class="p">,</span><span class="n">n</span><span class="p">,</span><span class="n">m</span><span class="o">+</span><span class="n">n</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span><span class="n">arraySize</span><span class="p">);</span>
|
||
</span></span><span class="line"><span class="cl"><span class="p">}</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><ol start="9">
|
||
<li>线性表$(a_1,a_2,a_3,\cdots,a_n)$中的元素递增有序且安顺序存储于计算机内，要求设计一个算法，完成用最少时间在表中查找数值为x的元素，若找到，则将其与后继元素位置相交换，若找不到，则将其插入表中并使表中元素仍递增有序</li>
|
||
</ol>
|
||
<p>算法思想：顺序存储的线性表递增有序，可以顺序查找，也可以折半查找，题目要求"用最少的时间在表中查找数值为x的元素"，这里应使用折半查找法</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
|
||
</span><span class="lnt"> 2
|
||
</span><span class="lnt"> 3
|
||
</span><span class="lnt"> 4
|
||
</span><span class="lnt"> 5
|
||
</span><span class="lnt"> 6
|
||
</span><span class="lnt"> 7
|
||
</span><span class="lnt"> 8
|
||
</span><span class="lnt"> 9
|
||
</span><span class="lnt">10
|
||
</span><span class="lnt">11
|
||
</span><span class="lnt">12
|
||
</span><span class="lnt">13
|
||
</span><span class="lnt">14
|
||
</span><span class="lnt">15
|
||
</span><span class="lnt">16
|
||
</span><span class="lnt">17
|
||
</span><span class="lnt">18
|
||
</span><span class="lnt">19
|
||
</span><span class="lnt">20
|
||
</span><span class="lnt">21
|
||
</span><span class="lnt">22
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c++" data-lang="c++"><span class="line"><span class="cl"><span class="kt">void</span> <span class="nf">SearchExchangeInsert</span><span class="p">(</span><span class="n">EkemType</span> <span class="n">A</span><span class="p">[],</span><span class="n">ElemType</span> <span class="n">x</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="kt">int</span> <span class="n">low</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span><span class="n">high</span><span class="o">=</span><span class="n">n</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span><span class="n">mid</span><span class="p">;</span> <span class="c1">//low和high指向顺序表的上界和下界的下标
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">while</span><span class="p">(</span><span class="n">low</span><span class="o"><=</span><span class="n">high</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">mid</span> <span class="o">=</span> <span class="p">(</span><span class="n">low</span><span class="o">+</span><span class="n">high</span><span class="p">)</span><span class="o">/</span><span class="mi">2</span><span class="p">;</span> <span class="c1">//找中间位置
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">if</span><span class="p">(</span><span class="n">A</span><span class="p">[</span><span class="n">mid</span><span class="p">]</span><span class="o">==</span><span class="n">x</span><span class="p">)</span> <span class="c1">//找到x，退出while循环
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">break</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">else</span> <span class="k">if</span><span class="p">(</span><span class="n">A</span><span class="p">[</span><span class="n">mid</span><span class="p">]</span><span class="o"><</span><span class="n">x</span><span class="p">)</span> <span class="c1">//到中点mid的右半部去查找
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">low</span><span class="o">=</span><span class="n">mid</span><span class="o">+</span><span class="mi">1</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">else</span> <span class="c1">//到中点mid的左半部去查
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">high</span><span class="o">=</span><span class="n">mid</span><span class="o">-</span><span class="mi">1</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">if</span><span class="p">(</span><span class="n">A</span><span class="p">[</span><span class="n">mid</span><span class="p">]</span><span class="o">==</span><span class="n">x</span><span class="o">&&</span><span class="n">mid</span><span class="o">!=</span><span class="n">n</span><span class="o">-</span><span class="mi">1</span><span class="p">){.</span> <span class="c1">//若最后一个元素与x相等，则不存在与其后继交换的操作
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">t</span><span class="o">=</span><span class="n">A</span><span class="p">[</span><span class="n">mid</span><span class="p">];</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">A</span><span class="p">[</span><span class="n">mid</span><span class="p">]</span><span class="o">=</span><span class="n">A</span><span class="p">[</span><span class="n">mid</span><span class="o">+</span><span class="mi">1</span><span class="p">];</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">A</span><span class="p">[</span><span class="n">mid</span><span class="o">+</span><span class="mi">1</span><span class="p">]</span><span class="o">=</span><span class="n">t</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">if</span><span class="p">(</span><span class="n">low</span><span class="o">></span><span class="n">high</span><span class="p">){</span> <span class="c1">//查找失败，插入数据元素x
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">for</span><span class="p">(</span><span class="n">i</span><span class="o">=</span><span class="n">n</span><span class="o">-</span><span class="mi">1</span><span class="p">;</span><span class="n">i</span><span class="o">></span><span class="n">high</span><span class="p">;</span><span class="n">i</span><span class="o">--</span><span class="p">)</span> <span class="c1">//后移元素
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">A</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">]</span><span class="o">=</span><span class="n">A</span><span class="p">[</span><span class="n">i</span><span class="p">];</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">A</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">]</span><span class="o">=</span><span class="n">x</span><span class="p">;</span> <span class="c1">//插入x
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"><span class="p">}</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><ol start="10">
|
||
<li>设将$n(n>1)$个整数存放到一维数组R中，设计一个在时间和空间两方面都尽可能高效的算法，将R中保存的序列循环左移$p(0<p<n)$个位置，即将R中的数据由$(X_0,X_1,X_2,\cdots,X_{n-1})$变换为$(X_p,X_{p+1},\cdots,X_{n-1},X_0,X_1,\cdots,X_{p-1})$。要求：</li>
|
||
</ol>
|
||
<p>1）给出算法设计思想</p>
|
||
<p>算法的基本设计思想：可将这个问题视为吧数组ab转换成数组ba(a代表数组的前p个元素，b代表数组中余下的n-p个元素)，先将a逆置得到$a^{-1}b$,再将b逆置得到$a^{-1}b^{-1}$,最后将整个$a^{-1}b^{-1}$逆置得到$(a^{-1}b^{-1})^{-1}=ba$。设Reverse函数执行将数组元素逆置的操作，对abcdefgh向左循环移动3个位置的过程如下：</p>
|
||
<pre><code>Reverse(0,p-1);得到cbadefgh
|
||
|
||
Reverse(p,p-1);得到cbahgfed;
|
||
|
||
Reverse(0,p-1);得到defghabc;
|
||
</code></pre>
|
||
<p>2）采用C或C++或java语言描述算法，关键之处给出注释</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
|
||
</span><span class="lnt"> 2
|
||
</span><span class="lnt"> 3
|
||
</span><span class="lnt"> 4
|
||
</span><span class="lnt"> 5
|
||
</span><span class="lnt"> 6
|
||
</span><span class="lnt"> 7
|
||
</span><span class="lnt"> 8
|
||
</span><span class="lnt"> 9
|
||
</span><span class="lnt">10
|
||
</span><span class="lnt">11
|
||
</span><span class="lnt">12
|
||
</span><span class="lnt">13
|
||
</span><span class="lnt">14
|
||
</span><span class="lnt">15
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c++" data-lang="c++"><span class="line"><span class="cl"><span class="kt">void</span> <span class="nf">Reverse</span><span class="p">(</span><span class="kt">int</span> <span class="n">R</span><span class="p">[],</span><span class="kt">int</span> <span class="n">from</span><span class="p">,</span><span class="kt">int</span> <span class="n">to</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="kt">int</span> <span class="n">i</span><span class="p">,</span><span class="n">temp</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">for</span><span class="p">(</span><span class="n">i</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span><span class="n">i</span><span class="o"><</span><span class="p">(</span><span class="n">to</span><span class="o">-</span><span class="n">from</span><span class="o">+</span><span class="mi">1</span><span class="p">)</span><span class="o">/</span><span class="mi">2</span><span class="p">;</span><span class="n">i</span><span class="o">++</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">temp</span><span class="o">=</span><span class="n">R</span><span class="p">[</span><span class="n">from</span><span class="o">+</span><span class="n">i</span><span class="p">];</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">R</span><span class="p">[</span><span class="n">from</span><span class="o">+</span><span class="n">i</span><span class="p">]</span><span class="o">=</span><span class="n">R</span><span class="p">[</span><span class="n">to</span><span class="o">-</span><span class="n">i</span><span class="p">];</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">R</span><span class="p">[</span><span class="n">to</span><span class="o">-</span><span class="n">i</span><span class="p">]</span><span class="o">=</span><span class="n">temp</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="p">}</span> <span class="c1">//Reverse
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl">
|
||
</span></span><span class="line"><span class="cl"><span class="kt">void</span> <span class="nf">Converse</span><span class="p">(</span><span class="kt">int</span> <span class="n">R</span><span class="p">[],</span><span class="kt">int</span> <span class="n">n</span><span class="p">,</span><span class="kt">int</span> <span class="n">p</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">Reverse</span><span class="p">(</span><span class="n">R</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="n">p</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">Reverse</span><span class="p">(</span><span class="n">R</span><span class="p">,</span><span class="n">p</span><span class="p">,</span><span class="n">p</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">Reverse</span><span class="p">(</span><span class="n">R</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="n">p</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
|
||
</span></span><span class="line"><span class="cl">
|
||
</span></span><span class="line"><span class="cl"><span class="p">}</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><p>3）说明算法时间空间复杂度</p>
|
||
<p>上述三个Reverse函数的时间复杂度分别为$O(p/2)、O((n-p)/2)$和$O(n/2)$故所设计的算法的时间复杂度为$O(n)$,空间复杂度为$O(1)$</p>
|
||
<ol start="11">
|
||
<li>一个长度为$L(L \leq 1)$的升序序列S，处在第[L/2]个位置的数称为S的中位数。例如序列$S_1$=(11,13,15,17,19),则$S_1$的中位数是15，两个序列的中位数是含它们所有元素的升序序列的中位数。例如$S_2$=(2,4,6,8,20)，则$S_1和S_2$的中位数是11.现在有两个等长升序序列A和B，试设计一个在时间和空间都尽可能高效的算法找出两个序列A和B的中位数。要求：</li>
|
||
</ol>
|
||
<p>1）给出算法设计思想</p>
|
||
<p>算法的基本设计思想：</p>
|
||
<p>分别求两个升序序列A，B的中位数，设为a和b，求序列A,B的中位数过程如下：</p>
|
||
<ol>
|
||
<li>若a=b，则a或b即为所求中位数，算法结束</li>
|
||
<li>若a<b,则舍弃序列A中较小的一半，同时舍弃序列B中较大的一半，要求两次舍弃的长度相等</li>
|
||
<li>若a>b，则舍弃序列A中较大的一半，同时舍弃序列B中较小的一半，要求两次舍弃的长度相等。</li>
|
||
</ol>
|
||
<p>在保留的两个升序序列中，重复过程1，2，3，直到两个序列中均只含有一个元素时为止，较小者即为所求的中位数</p>
|
||
<p>2）采用C或C++或java语言描述算法，关键之处给出注释</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
|
||
</span><span class="lnt"> 2
|
||
</span><span class="lnt"> 3
|
||
</span><span class="lnt"> 4
|
||
</span><span class="lnt"> 5
|
||
</span><span class="lnt"> 6
|
||
</span><span class="lnt"> 7
|
||
</span><span class="lnt"> 8
|
||
</span><span class="lnt"> 9
|
||
</span><span class="lnt">10
|
||
</span><span class="lnt">11
|
||
</span><span class="lnt">12
|
||
</span><span class="lnt">13
|
||
</span><span class="lnt">14
|
||
</span><span class="lnt">15
|
||
</span><span class="lnt">16
|
||
</span><span class="lnt">17
|
||
</span><span class="lnt">18
|
||
</span><span class="lnt">19
|
||
</span><span class="lnt">20
|
||
</span><span class="lnt">21
|
||
</span><span class="lnt">22
|
||
</span><span class="lnt">23
|
||
</span><span class="lnt">24
|
||
</span><span class="lnt">25
|
||
</span><span class="lnt">26
|
||
</span><span class="lnt">27
|
||
</span><span class="lnt">28
|
||
</span><span class="lnt">29
|
||
</span><span class="lnt">30
|
||
</span><span class="lnt">31
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c++" data-lang="c++"><span class="line"><span class="cl"><span class="kt">int</span> <span class="nf">M_Search</span><span class="p">(</span><span class="kt">int</span> <span class="n">A</span><span class="p">[],</span><span class="kt">int</span> <span class="n">B</span><span class="p">[],</span><span class="kt">int</span> <span class="n">n</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="kt">int</span> <span class="n">s1</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span><span class="n">d1</span><span class="o">=</span><span class="n">n</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span><span class="n">m1</span><span class="p">,</span><span class="n">s2</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span><span class="n">d2</span><span class="o">=</span><span class="n">n</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span><span class="n">m2</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="c1">//分别表示序列A和B的首位数，末位数和中位数
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">while</span><span class="p">(</span><span class="n">s1</span><span class="o">!=</span><span class="n">d1</span><span class="o">||</span><span class="n">s2</span><span class="o">!=</span><span class="n">d2</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">m1</span><span class="o">=</span><span class="p">(</span><span class="n">s1</span><span class="o">+</span><span class="n">d1</span><span class="p">)</span><span class="o">/</span><span class="mi">2</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">m2</span><span class="o">=</span><span class="p">(</span><span class="n">s2</span><span class="o">+</span><span class="n">d2</span><span class="p">)</span><span class="o">/</span><span class="mi">2</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">if</span><span class="p">(</span><span class="n">A</span><span class="p">[</span><span class="n">m1</span><span class="p">]</span><span class="o">==</span><span class="n">B</span><span class="p">[</span><span class="n">m2</span><span class="p">])</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="n">A</span><span class="p">[</span><span class="n">m1</span><span class="p">];</span> <span class="c1">//满足过程1
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">if</span><span class="p">(</span><span class="n">A</span><span class="p">[</span><span class="n">m1</span><span class="p">]</span><span class="o"><</span><span class="n">B</span><span class="p">[</span><span class="n">m2</span><span class="p">]){</span> <span class="c1">//满足过程2
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">if</span><span class="p">((</span><span class="n">s1</span><span class="o">+</span><span class="n">d1</span><span class="p">)</span><span class="o">%</span><span class="mi">2</span><span class="o">==</span><span class="mi">0</span><span class="p">){</span> <span class="c1">//若元素个数为奇数
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">s1</span><span class="o">=</span><span class="n">m1</span><span class="p">;</span> <span class="c1">//舍弃A中间点以前的部分且保留中间点
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">d2</span><span class="o">=</span><span class="n">m2</span><span class="p">;</span> <span class="c1">//舍弃B中间点以后的部分且保留中间点
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">else</span><span class="p">{</span> <span class="c1">//元素个数为偶数
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">s1</span><span class="o">=</span><span class="n">m1</span><span class="o">+</span><span class="mi">1</span><span class="p">;</span> <span class="c1">//舍弃A中间点及中间点以前部分
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">d2</span><span class="o">=</span><span class="n">m2</span><span class="p">;</span> <span class="c1">//舍弃B中间点以后部分且保留中间点
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">else</span><span class="p">{.</span> <span class="c1">//满足过程3
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">if</span><span class="p">((</span><span class="n">s2</span><span class="o">+</span><span class="n">d2</span><span class="p">)</span><span class="o">%</span><span class="mi">2</span><span class="o">==</span><span class="mi">0</span><span class="p">){</span> <span class="c1">//若元素个数为奇数
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">d1</span><span class="o">=</span><span class="n">m1</span><span class="p">;</span> <span class="c1">//舍弃A中间点以后的部分且保留中间点
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">s2</span><span class="o">=</span><span class="n">m2</span><span class="p">;</span> <span class="c1">//舍弃B中间点以前的部分且保留中间点
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">else</span><span class="p">{</span> <span class="c1">//元素个数为偶数
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">d1</span><span class="o">=</span><span class="n">m1</span><span class="p">;</span> <span class="c1">//舍弃A中间点以后部分且保留中间点
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">s2</span><span class="o">=</span><span class="n">m2</span><span class="o">+</span><span class="mi">1</span><span class="p">;</span><span class="c1">//舍弃B中间点及中间点以前部分
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="n">A</span><span class="p">[</span><span class="n">s1</span><span class="p">]</span><span class="o"><</span><span class="n">B</span><span class="p">[</span><span class="n">s2</span><span class="p">]</span> <span class="o">?</span> <span class="n">A</span><span class="p">[</span><span class="n">s1</span><span class="p">]</span><span class="o">:</span><span class="n">B</span><span class="p">[</span><span class="n">s2</span><span class="p">];</span>
|
||
</span></span><span class="line"><span class="cl"><span class="p">}</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><p>3）说明算法时间空间复杂度</p>
|
||
<p>算法的时间复杂度为$O(\log_2 n)$,空间复杂度为$O(1)$</p>
|
||
<ol start="12">
|
||
<li>已知一个整数序列$A=(a_0,a_1,\cdots,a_{n-1})$,其中$0 \leq a_i < n(0 \leq i < n)$。若存在$a_{p1}=a_{p2}=\cdots=a_{pm}=x$且$m>n/2(0\leq p_k < n,1 \leq k \leq m)$,则称x为A的主元素，例如A=(0,5,5,3,5,7,5,5),则5为主元素；又如A=(0,5,5,3,5,1,5,7),则A中没有主元素。假设A中的n个元素保存在一个一维数组中，请设计一个尽可能高效的算法，找出A的主元素，若存在主元素，则输出该元素，否则输出-1，要求</li>
|
||
</ol>
|
||
<p>1）给出算法设计思想</p>
|
||
<p>算法的基本设计思想：从前往后扫描数组元素，标记出一个可能成为主元素的元素num，然后重新计数，确认num是否是主元素</p>
|
||
<ol>
|
||
<li>选取候选的主元素，依次扫描所给数组中的每个整数，将第一个遇到的整数Num保存到c中，记录num的出现次数为1；若遇到的下一个整数仍然等于num，则计数加一，否则计数减一；当计数减到0时，将遇到的下一个整数保存到c中，计数重新记为一，开始新一轮计数，即从当前位置开始重复上述过程，直到扫描完全部数组元素</li>
|
||
<li>判断c中元素是否是真正的主元素。再次扫描该数组，统计c中元素出现的次数，若等于n/2，则为主元素；否则，序列中不存在主元素</li>
|
||
</ol>
|
||
<p>2）采用C或C++或java语言描述算法，关键之处给出注释</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
|
||
</span><span class="lnt"> 2
|
||
</span><span class="lnt"> 3
|
||
</span><span class="lnt"> 4
|
||
</span><span class="lnt"> 5
|
||
</span><span class="lnt"> 6
|
||
</span><span class="lnt"> 7
|
||
</span><span class="lnt"> 8
|
||
</span><span class="lnt"> 9
|
||
</span><span class="lnt">10
|
||
</span><span class="lnt">11
|
||
</span><span class="lnt">12
|
||
</span><span class="lnt">13
|
||
</span><span class="lnt">14
|
||
</span><span class="lnt">15
|
||
</span><span class="lnt">16
|
||
</span><span class="lnt">17
|
||
</span><span class="lnt">18
|
||
</span><span class="lnt">19
|
||
</span><span class="lnt">20
|
||
</span><span class="lnt">21
|
||
</span><span class="lnt">22
|
||
</span><span class="lnt">23
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c++" data-lang="c++"><span class="line"><span class="cl"><span class="kt">int</span> <span class="nf">Majority</span><span class="p">(</span><span class="kt">int</span> <span class="n">A</span><span class="p">[],</span><span class="kt">int</span> <span class="n">n</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="kt">int</span> <span class="n">i</span><span class="p">,</span><span class="n">c</span><span class="p">,</span><span class="n">count</span><span class="o">=</span><span class="mi">1</span><span class="p">;</span> <span class="c1">//c用来保存候选主元素，count计数
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">c</span><span class="o">=</span><span class="n">A</span><span class="p">[</span><span class="mi">0</span><span class="p">];</span> <span class="c1">//设置A[0]为候选主元素
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">for</span><span class="p">(</span><span class="n">i</span><span class="o">=</span><span class="mi">1</span><span class="p">;</span><span class="n">i</span><span class="o"><</span><span class="n">n</span><span class="p">;</span><span class="n">i</span><span class="o">++</span><span class="p">)</span> <span class="c1">//查找候选主元素
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">if</span><span class="p">(</span><span class="n">A</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">==</span><span class="n">c</span><span class="p">)</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">count</span><span class="o">++</span><span class="p">;</span> <span class="c1">//对A中的候选主元素计数
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">else</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">if</span><span class="p">(</span><span class="n">count</span><span class="o">></span><span class="mi">0</span><span class="p">)</span> <span class="c1">//处理不是候选主元素的情况
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">count</span><span class="o">--</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">else</span><span class="p">{</span> <span class="c1">//更换候选主元素，重新计数
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">c</span><span class="o">=</span><span class="n">A</span><span class="p">[</span><span class="n">i</span><span class="p">];</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">count</span><span class="o">=</span><span class="mi">1</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">if</span><span class="p">(</span><span class="n">count</span><span class="o">></span><span class="mi">0</span><span class="p">)</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">for</span><span class="p">(</span><span class="n">i</span><span class="o">=</span><span class="n">count</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span><span class="n">i</span><span class="o"><</span><span class="n">n</span><span class="p">;</span><span class="n">i</span><span class="o">++</span><span class="p">)</span> <span class="c1">//统计候选主元素的实际出现次数
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">if</span><span class="p">(</span><span class="n">A</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">==</span><span class="n">c</span><span class="p">)</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">count</span><span class="o">++</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">if</span><span class="p">(</span><span class="n">count</span><span class="o">></span><span class="n">n</span><span class="o">/</span><span class="mi">2</span><span class="p">)</span> <span class="c1">//确认候选主元素
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">return</span> <span class="n">c</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">else</span> <span class="c1">//不存在主元素
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">return</span> <span class="o">-</span><span class="mi">1</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl">
|
||
</span></span><span class="line"><span class="cl"><span class="p">}</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><p>3）说明算法时间空间复杂度</p>
|
||
<p>时间复杂度为$O(n)$，空间复杂度为$O(1)$</p>
|
||
<ol start="13">
|
||
<li>给定一个含$n(n \geq 1)$个整数的数组，请设计一个在时间上尽可能高效的算法，找出数组中未出现的最小正整数，例如，数组{-5,3,2,3}中未出现的最小正整数是1；数组{1,2,3}中未出现的最小正整数是4，要求：</li>
|
||
</ol>
|
||
<p>1）给出算法设计思想</p>
|
||
<p>思路：采用空间换时间的方法，分配一个用于标记的数组B[n],用于记录A中是否出现了1～n中的正整数，B[0]对应正整数1，B[n-1]对应正整数n，初始化B中全部为0，由于A中含有n个整数,因此可能的返回值是1~n+1，当A中n个数恰好为1~n时返回n+1。当数组A中出现了小于等于0或大于n的值时，会导致1~n中出现空余位置，返回结果必然在1~n中，因此对于A中出现了小于等于0或大于n的值，可以不采取任何操作</p>
|
||
<p>算法流程：从A[0]开始遍历A，若0<A[i]<=n,则令B[A[i]-1]=1;否则不做操作。对A遍历结束后，开始遍历数组B，若能查找到第一个满足B[i]==0的下标i，返回i+1即为结果，此时说明A中未出现的最小正整数在1~n之间。若B[i]全部不为0，返回i+1(跳出循环时i=n，i+1等于n+1)，此时说明A中未出现的最小正整数是n+1</p>
|
||
<p>2）采用C或C++或java语言描述算法，关键之处给出注释</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
|
||
</span><span class="lnt"> 2
|
||
</span><span class="lnt"> 3
|
||
</span><span class="lnt"> 4
|
||
</span><span class="lnt"> 5
|
||
</span><span class="lnt"> 6
|
||
</span><span class="lnt"> 7
|
||
</span><span class="lnt"> 8
|
||
</span><span class="lnt"> 9
|
||
</span><span class="lnt">10
|
||
</span><span class="lnt">11
|
||
</span><span class="lnt">12
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="kt">int</span> <span class="nf">findMissMin</span><span class="p">(</span><span class="kt">int</span> <span class="n">A</span><span class="p">[],</span><span class="kt">int</span> <span class="n">n</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="kt">int</span> <span class="n">i</span><span class="p">,</span><span class="o">*</span><span class="n">B</span><span class="p">;</span> <span class="c1">//标记数组
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">B</span><span class="o">=</span><span class="p">(</span><span class="kt">int</span><span class="o">*</span> <span class="p">)</span><span class="nf">malloc</span><span class="p">(</span><span class="k">sizeof</span><span class="p">(</span><span class="kt">int</span><span class="p">)</span><span class="o">*</span><span class="n">n</span><span class="p">);</span> <span class="c1">//分配空间
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="nf">memset</span><span class="p">(</span><span class="n">B</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="nf">siezof</span><span class="p">(</span><span class="kt">int</span><span class="p">)</span><span class="o">*</span><span class="n">n</span><span class="p">);</span> <span class="c1">//赋初值为0
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">for</span><span class="p">(</span><span class="n">i</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span><span class="n">i</span><span class="o"><</span><span class="n">n</span><span class="p">;</span><span class="n">i</span><span class="o">++</span><span class="p">)</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">if</span><span class="p">(</span><span class="n">A</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">></span><span class="mi">0</span><span class="o">&&</span><span class="n">A</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o"><=</span><span class="n">n</span><span class="p">)</span> <span class="c1">//若A[i]的值介于1~n，则标记数组B
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">B</span><span class="p">[</span><span class="n">A</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span><span class="o">=</span><span class="mi">1</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">for</span><span class="p">(</span><span class="n">i</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span><span class="n">i</span><span class="o"><</span><span class="n">n</span><span class="p">;</span><span class="n">i</span><span class="o">++</span><span class="p">)</span> <span class="c1">//扫描数组B，找到目标值
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">if</span><span class="p">(</span><span class="n">B</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">==</span><span class="mi">0</span><span class="p">)</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">break</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">;</span> <span class="c1">//返回结果
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">}</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><p>3）说明算法时间空间复杂度</p>
|
||
<p>时间复杂度：A,B各遍历一次，两次循环内操作步骤为$O(1)$量级，因此时间复杂度为$O(n)$</p>
|
||
<ol start="14">
|
||
<li>定义三元组(a,b,c)(a、b、c均为正数)的距离D=|a-b| + |b-c|+|c-a|。给定3个非空整数集合$S_1、S_2、S_3$,按升序分别存储在3个数组中。请设计一个尽可能高效的算法，计算并输出所有可能的三元组$(a,b,c)(a \in S_1,b \in S_2,c \in S_3)$中的最小距离。例如$S_1={-1,0,9},S_2={-25,-10,10,11},S_3={2,9,17,30,41},则最小距离为2，相应的三元组为(9,10,9)。要求：</li>
|
||
</ol>
|
||
<p>1）给出算法设计思想</p>
|
||
<ul>
|
||
<li>思路：由$D=|a-b|+|b-c|+|c-a| \geq 0$可得：</li>
|
||
</ul>
|
||
<ul>
|
||
<li>a=b=c时，距离最小</li>
|
||
<li>假设$a \leq b \leq c$可得$L_1=|a-b| L_2=|b-c| L_3=|c-a| D=|a-b|+|b-c|+|c-a|=L_1+L_2+L_3=2L_3$</li>
|
||
</ul>
|
||
<p>由此可得a和c的距离决定D的大小，问题简化为为每次固定的c找一个a，使得$L_3=|c-a|最小$</p>
|
||
<ul>
|
||
<li>算法的设计思想：</li>
|
||
</ul>
|
||
<ol>
|
||
<li>使用$D_{min}$记录所有已处理的三元组的最小距离，初值为一个足够大的整数。</li>
|
||
<li>集合$S_1,S_2,S_3$分别保存在数组A,B,C中。数组的下标变量i=j=k=0，当$i<|S_1|,j<|S_2|,k<|S_3|$时，循环执行下面的步骤</li>
|
||
</ol>
|
||
<ul>
|
||
<li>计算A[i],B[j],C[k]的距离D</li>
|
||
<li>若$D<D_{min} $,则$D_{min} = D$</li>
|
||
<li>将A[i],B[j],C[k]中的最小值的下标+1(最小值为a，最大值为c，此处c不变更新a，试图寻找更小的距离D)</li>
|
||
<li>输出$D_{min}$，结束</li>
|
||
</ul>
|
||
<p>2）采用C或C++或java语言描述算法，关键之处给出注释</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
|
||
</span><span class="lnt"> 2
|
||
</span><span class="lnt"> 3
|
||
</span><span class="lnt"> 4
|
||
</span><span class="lnt"> 5
|
||
</span><span class="lnt"> 6
|
||
</span><span class="lnt"> 7
|
||
</span><span class="lnt"> 8
|
||
</span><span class="lnt"> 9
|
||
</span><span class="lnt">10
|
||
</span><span class="lnt">11
|
||
</span><span class="lnt">12
|
||
</span><span class="lnt">13
|
||
</span><span class="lnt">14
|
||
</span><span class="lnt">15
|
||
</span><span class="lnt">16
|
||
</span><span class="lnt">17
|
||
</span><span class="lnt">18
|
||
</span><span class="lnt">19
|
||
</span><span class="lnt">20
|
||
</span><span class="lnt">21
|
||
</span><span class="lnt">22
|
||
</span><span class="lnt">23
|
||
</span><span class="lnt">24
|
||
</span><span class="lnt">25
|
||
</span><span class="lnt">26
|
||
</span><span class="lnt">27
|
||
</span><span class="lnt">28
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="cp">#define INT_MAX 0x7fffffff
|
||
</span></span></span><span class="line"><span class="cl"><span class="cp"></span><span class="kt">int</span> <span class="nf">abs_</span><span class="p">(</span><span class="kt">int</span> <span class="n">a</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">if</span><span class="p">(</span><span class="n">a</span><span class="o"><</span><span class="mi">0</span><span class="p">)</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="o">-</span><span class="n">a</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">else</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="n">a</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"><span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"><span class="kt">bool</span> <span class="nf">xls_min</span><span class="p">(</span><span class="kt">int</span> <span class="n">a</span><span class="p">,</span><span class="kt">int</span> <span class="n">b</span><span class="p">,</span><span class="kt">int</span> <span class="n">c</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">if</span><span class="p">(</span><span class="n">a</span><span class="o"><=</span><span class="n">b</span><span class="o">&&</span><span class="n">a</span><span class="o"><=</span><span class="n">c</span><span class="p">)</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nb">true</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nb">false</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"><span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"><span class="kt">int</span> <span class="nf">findMinofTrip</span><span class="p">(</span><span class="kt">int</span> <span class="n">A</span><span class="p">[],</span><span class="kt">int</span> <span class="n">n</span><span class="p">,</span><span class="kt">int</span> <span class="n">B</span><span class="p">[],</span><span class="kt">int</span> <span class="n">m</span><span class="p">,</span><span class="kt">int</span> <span class="n">C</span><span class="p">[],</span><span class="kt">int</span> <span class="n">p</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="kt">int</span> <span class="n">i</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span><span class="n">j</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span><span class="n">k</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span><span class="n">D_min</span><span class="o">=</span><span class="n">INT_MAX</span><span class="p">,</span><span class="n">D</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">while</span><span class="p">(</span><span class="n">i</span><span class="o"><</span><span class="n">n</span><span class="o">&&</span><span class="n">j</span><span class="o"><</span><span class="n">m</span><span class="o">&&</span><span class="n">k</span><span class="o"><</span><span class="n">p</span><span class="o">&&</span><span class="n">D_min</span><span class="o">></span><span class="mi">0</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">D</span><span class="o">=</span><span class="nf">abs_</span><span class="p">(</span><span class="n">A</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">-</span><span class="n">B</span><span class="p">[</span><span class="n">j</span><span class="p">])</span><span class="o">+</span><span class="nf">abs_</span><span class="p">(</span><span class="n">B</span><span class="p">[</span><span class="n">j</span><span class="p">]</span><span class="o">-</span><span class="n">C</span><span class="p">[</span><span class="n">k</span><span class="p">])</span><span class="o">+</span><span class="nf">abs_</span><span class="p">(</span><span class="n">C</span><span class="p">[</span><span class="n">k</span><span class="p">]</span><span class="o">-</span><span class="n">A</span><span class="p">[</span><span class="n">i</span><span class="p">]);</span> <span class="c1">//计算D
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">if</span><span class="p">(</span><span class="n">D</span><span class="o"><</span><span class="n">D_min</span><span class="p">)</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">D_min</span> <span class="o">=</span> <span class="n">D</span><span class="p">;</span> <span class="c1">//更新D
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">if</span><span class="p">(</span><span class="nf">xls_min</span><span class="p">(</span><span class="n">A</span><span class="p">[</span><span class="n">i</span><span class="p">],</span><span class="n">B</span><span class="p">[</span><span class="n">j</span><span class="p">],</span><span class="n">C</span><span class="p">[</span><span class="n">k</span><span class="p">]))</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">i</span><span class="o">++</span><span class="p">;</span> <span class="c1">//更新a
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">else</span> <span class="k">if</span><span class="p">(</span><span class="nf">xls_min</span><span class="p">(</span><span class="n">B</span><span class="p">[</span><span class="n">j</span><span class="p">],</span><span class="n">C</span><span class="p">[</span><span class="n">k</span><span class="p">],</span><span class="n">A</span><span class="p">[</span><span class="n">i</span><span class="p">]))</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">j</span><span class="o">++</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">else</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">k</span><span class="o">++</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl">
|
||
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="n">D_min</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"><span class="p">}</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><p>3）说明算法时间空间复杂度</p>
|
||
<p>设$n=(|S_1|+|S_2|+|S_3|)$,可得时间复杂度为$O(n)$空间复杂度为$O(1)$</p>
|
||
<h2 id="线性表的链式表示"><a href="#线性表的链式表示" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>线性表的链式表示</h2>
|
||
<h3 id="单链表定义"><a href="#单链表定义" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>单链表定义</h3>
|
||
<p>线性表的链式存储称为单链表，通过一组任意的存储单元来存储线性表中的数据元素，对于每个链表结点，除存放元素自身元素以外，还需要存放一个指向其后继的指针</p>
|
||
<div class="table-container"><table>
|
||
<thead>
|
||
<tr>
|
||
<th style="text-align:center">data</th>
|
||
<th style="text-align:center">next</th>
|
||
</tr>
|
||
</thead>
|
||
</table></div>
|
||
<p>如上，data为数据域，存放数据元素，next为指针域，存放后继结点的地址</p>
|
||
<p>对结点类型的定义如下：</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt">1
|
||
</span><span class="lnt">2
|
||
</span><span class="lnt">3
|
||
</span><span class="lnt">4
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="k">typedef</span> <span class="k">struct</span> <span class="n">LNode</span><span class="p">{</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">ElemType</span> <span class="n">data</span><span class="p">;</span> <span class="c1">// 数据域
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">struct</span> <span class="n">LNode</span> <span class="o">*</span><span class="n">next</span><span class="p">;</span> <span class="c1">//指针域
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">}</span><span class="n">LNode</span><span class="p">,</span><span class="o">*</span><span class="n">LinkList</span><span class="p">;</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><p>单链表可解决顺序表需要大量连续存储单元的问题，但其本身附加指针域，会导致浪费存储空间，且单链表的元素离散分布在存储空间中(非随机存取结构)，查找某个特定结点时，需要从表头开始遍历</p>
|
||
<p>头指针通常用于标识一个单链表，如单链表L，头指针为NULL时表示为一个空表，出于便于操作的目的，也会在单链表的第一个结点之前附加一个结点，称为头结点。头结点的数据域可以不设任何信息，也可以记录表长等信息。头结点的指针指向线性表的第一个元素结点</p>
|
||
<p>头结点和头指针的区别：</p>
|
||
<ul>
|
||
<li>头指针始终指向链表的第一个结点</li>
|
||
<li>头结点是带头结点的链表中的第一个结点，结点内通常不存储信息</li>
|
||
</ul>
|
||
<p>头结点引入的优势：</p>
|
||
<ul>
|
||
<li>由于第一个元素结点的位置被放在头结点的指针域中，因而在链表第一个位置上的操作与其他位置保持一致</li>
|
||
<li>无论链表是否为空，头指针都指向头结点的非空指针(空表中头结点的指针域为空)，统一了对空表和非空表的处理</li>
|
||
</ul>
|
||
<h3 id="单链表的基本操作"><a href="#单链表的基本操作" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>单链表的基本操作</h3>
|
||
<h4 id="采用头插法建立单链表"><a href="#采用头插法建立单链表" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>采用头插法建立单链表</h4>
|
||
<p>该方法从一个空表开始，生成新结点，并把读取到的数据存放到新结点的数据域中，然后将新结点插入到头结点之后</p>
|
||
<p>算法如下：</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
|
||
</span><span class="lnt"> 2
|
||
</span><span class="lnt"> 3
|
||
</span><span class="lnt"> 4
|
||
</span><span class="lnt"> 5
|
||
</span><span class="lnt"> 6
|
||
</span><span class="lnt"> 7
|
||
</span><span class="lnt"> 8
|
||
</span><span class="lnt"> 9
|
||
</span><span class="lnt">10
|
||
</span><span class="lnt">11
|
||
</span><span class="lnt">12
|
||
</span><span class="lnt">13
|
||
</span><span class="lnt">14
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="n">LinkList</span> <span class="nf">List_HeadInsert</span><span class="p">(</span><span class="n">LinkList</span> <span class="o">&</span><span class="n">L</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">LNode</span> <span class="o">*</span><span class="n">s</span><span class="p">;</span> <span class="kt">int</span> <span class="n">x</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">L</span><span class="o">=</span><span class="p">(</span><span class="n">LinkList</span><span class="p">)</span><span class="nf">malloc</span><span class="p">(</span><span class="k">sizeof</span><span class="p">(</span><span class="n">LNode</span><span class="p">));</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">L</span><span class="o">-></span><span class="n">next</span> <span class="o">=</span> <span class="nb">NULL</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="nf">scanf</span><span class="p">(</span><span class="s">"%d"</span><span class="p">,</span><span class="o">&</span><span class="n">x</span><span class="p">);</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">while</span><span class="p">(</span><span class="n">x</span><span class="o">!=</span><span class="mi">9999</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">s</span><span class="o">=</span><span class="p">(</span><span class="n">LNode</span><span class="o">*</span><span class="p">)</span><span class="nf">malloc</span><span class="p">(</span><span class="k">sizeof</span><span class="p">(</span><span class="n">LNode</span><span class="p">));</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">s</span><span class="o">-></span><span class="n">data</span><span class="o">=</span><span class="n">x</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">s</span><span class="o">-></span><span class="n">next</span><span class="o">=</span><span class="n">L</span><span class="o">-></span><span class="n">next</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">L</span><span class="o">-></span><span class="n">next</span><span class="o">=</span><span class="n">s</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="nf">scanf</span><span class="p">(</span><span class="s">"%d"</span><span class="p">,</span><span class="o">&</span><span class="n">x</span><span class="p">);</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="n">L</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"><span class="p">}</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><p>读入数据的顺序与生成的链表中的元素的顺序是相反的，每个结点插入的时间为$O(1)$,设单链表长度为n，则总时间复杂度为$O(n)$</p>
|
||
<h4 id="采用尾插法建立单链表"><a href="#采用尾插法建立单链表" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>采用尾插法建立单链表</h4>
|
||
<p>该方法将新结点插入到当前链表的表尾，为此必须增加一个尾指针r，使其始终指向当前链表的尾结点</p>
|
||
<p>算法：</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
|
||
</span><span class="lnt"> 2
|
||
</span><span class="lnt"> 3
|
||
</span><span class="lnt"> 4
|
||
</span><span class="lnt"> 5
|
||
</span><span class="lnt"> 6
|
||
</span><span class="lnt"> 7
|
||
</span><span class="lnt"> 8
|
||
</span><span class="lnt"> 9
|
||
</span><span class="lnt">10
|
||
</span><span class="lnt">11
|
||
</span><span class="lnt">12
|
||
</span><span class="lnt">13
|
||
</span><span class="lnt">14
|
||
</span><span class="lnt">15
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="n">LinkList</span> <span class="nf">List_TailInsert</span><span class="p">(</span><span class="n">LinkList</span> <span class="o">&</span><span class="n">L</span><span class="p">){</span> <span class="c1">//正向建立单链表
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="kt">int</span> <span class="n">x</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">L</span><span class="o">=</span><span class="p">(</span><span class="n">LinkList</span><span class="p">)</span><span class="nf">malloc</span><span class="p">(</span><span class="k">sizeof</span><span class="p">(</span><span class="n">LNode</span><span class="p">));</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">LNode</span> <span class="o">*</span><span class="n">s</span><span class="p">,</span><span class="o">*</span><span class="n">r</span><span class="o">=</span><span class="n">L</span><span class="p">;</span> <span class="c1">//r为表尾指针
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="nf">scanf</span><span class="p">(</span><span class="s">"%d"</span><span class="p">,</span><span class="o">&</span><span class="n">x</span><span class="p">);</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">while</span><span class="p">(</span><span class="n">x</span><span class="o">!=</span><span class="mi">9999</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">s</span><span class="o">=</span><span class="p">(</span><span class="n">LNode</span> <span class="o">*</span><span class="p">)</span><span class="nf">malloc</span><span class="p">(</span><span class="k">sizeof</span><span class="p">(</span><span class="n">LNode</span><span class="p">));</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">s</span><span class="o">-></span><span class="n">data</span><span class="o">=</span><span class="n">x</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">r</span><span class="o">-></span><span class="n">next</span><span class="o">=</span><span class="n">s</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">r</span><span class="o">=</span><span class="n">s</span><span class="p">;</span> <span class="c1">//r指向新的表尾指针
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="nf">scanf</span><span class="p">(</span><span class="s">"%d"</span><span class="p">,</span><span class="o">&</span><span class="n">x</span><span class="p">);</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">r</span><span class="o">-></span><span class="n">next</span><span class="o">=</span><span class="nb">NULL</span><span class="p">;</span> <span class="c1">//尾结点指针置空
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">return</span> <span class="n">L</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"><span class="p">}</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><p>读入数据的顺序与生成的链表中的元素的顺序一致，附设了一个指向表尾结点的指针，故时间复杂度和头插法的相同，都为$O(n)$</p>
|
||
<h4 id="按序号查找结点值"><a href="#按序号查找结点值" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>按序号查找结点值</h4>
|
||
<p>在单链表中从第一个结点出发，顺指针next域逐个往下搜索，直到找到第i个结点为止，否则返回最后一个结点指针域NULL</p>
|
||
<p>算法：</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
|
||
</span><span class="lnt"> 2
|
||
</span><span class="lnt"> 3
|
||
</span><span class="lnt"> 4
|
||
</span><span class="lnt"> 5
|
||
</span><span class="lnt"> 6
|
||
</span><span class="lnt"> 7
|
||
</span><span class="lnt"> 8
|
||
</span><span class="lnt"> 9
|
||
</span><span class="lnt">10
|
||
</span><span class="lnt">11
|
||
</span><span class="lnt">12
|
||
</span><span class="lnt">13
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="n">LNode</span> <span class="o">*</span><span class="nf">GetElem</span><span class="p">(</span><span class="n">LinkList</span> <span class="n">L</span><span class="p">,</span><span class="kt">int</span> <span class="n">i</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="kt">int</span> <span class="n">j</span><span class="o">=</span><span class="mi">1</span><span class="p">;</span> <span class="c1">//计数，初始为1
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">LNode</span> <span class="o">*</span><span class="n">p</span><span class="o">=</span><span class="n">L</span><span class="o">-></span><span class="n">next</span><span class="p">;</span> <span class="c1">//头结点指针赋给p
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">if</span><span class="p">(</span><span class="n">i</span><span class="o">==</span><span class="mi">0</span><span class="p">)</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="n">L</span><span class="p">;</span> <span class="c1">//若i等于0，则返回头结点
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">if</span><span class="p">(</span><span class="n">i</span><span class="o"><</span><span class="mi">1</span><span class="p">)</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nb">NULL</span><span class="p">;</span> <span class="c1">//i无效则返回NULL
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">while</span><span class="p">(</span><span class="n">p</span><span class="o">&&</span><span class="n">j</span><span class="o"><</span><span class="n">i</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">p</span><span class="o">=</span><span class="n">p</span><span class="o">-></span><span class="n">next</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">j</span><span class="o">++</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="n">p</span><span class="p">;</span> <span class="c1">//返回第i个结点的指针，若i大于表长，则返回NULL
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">}</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><p>时间复杂度为$O(n)$</p>
|
||
<h4 id="按值查找表结点"><a href="#按值查找表结点" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>按值查找表结点</h4>
|
||
<p>从单链表的第一个结点开始，由前往后依次比较表中各结点数据域的值，若某结点数据域的值等于给定值e，则返回该结点的指针；若整个单链表中没有这样的结点，则返回NULL</p>
|
||
<p>算法：</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt">1
|
||
</span><span class="lnt">2
|
||
</span><span class="lnt">3
|
||
</span><span class="lnt">4
|
||
</span><span class="lnt">5
|
||
</span><span class="lnt">6
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="n">LNode</span> <span class="o">*</span><span class="nf">LocateElem</span><span class="p">(</span><span class="n">LinkList</span> <span class="n">L</span><span class="p">,</span><span class="n">ElemType</span> <span class="n">e</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">LNode</span> <span class="o">*</span><span class="n">p</span><span class="o">=</span><span class="n">L</span><span class="o">-></span><span class="n">next</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">while</span><span class="p">(</span><span class="n">p</span><span class="o">!=</span><span class="nb">NULL</span><span class="o">&&</span><span class="n">p</span><span class="o">-></span><span class="n">data</span><span class="o">!=</span><span class="n">e</span><span class="p">)</span> <span class="c1">//从第一个结点开始查找data域为e的结点
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">p</span><span class="o">=</span><span class="n">p</span><span class="o">-></span><span class="n">next</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="n">p</span><span class="p">;</span> <span class="c1">//找到后返回该结点指针，否则返回NULL
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">}</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><h4 id="插入结点操作"><a href="#插入结点操作" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>插入结点操作</h4>
|
||
<p>插入结点操作将值为x的新结点插入到单链表的第i个位置上。先检查插入位置的合法性，然后找到待插入位置的前驱结点，即第i-1个结点，再在其后插入新结点</p>
|
||
<p>算法首先调用按序号查找算法GetElem(L,i-1),查找第i-1个结点。假设返回的第i-1个结点为* p，然后令新结点* s的指针域指向* p的后继结点，再令结点* p的指针域指向新插入的结点* s</p>
|
||
<p>实现插入结点的代码片段：</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt">1
|
||
</span><span class="lnt">2
|
||
</span><span class="lnt">3
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="n">p</span><span class="o">=</span><span class="nf">GetElem</span><span class="p">(</span><span class="n">L</span><span class="p">,</span><span class="n">i</span><span class="o">-</span><span class="mi">1</span><span class="p">);</span>
|
||
</span></span><span class="line"><span class="cl"><span class="n">s</span><span class="o">-></span><span class="n">next</span><span class="o">=</span><span class="n">p</span><span class="o">-></span><span class="n">next</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"><span class="n">p</span><span class="o">-></span><span class="n">next</span><span class="o">=</span><span class="n">s</span><span class="p">;</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><p>上述片段中，指针操作顺序不能颠倒，否则，先执行p->next=s后，指向其原后继的指针就不存在，再执行s->next=p->next时，相当于执行了s->next=s，显然是错误的</p>
|
||
<p>主要的时间开销在于查找第i-1个元素，时间复杂度为$O(n)$.若在给定的节点后面插入新结点，则时间复杂度为$O(1)$</p>
|
||
<h4 id="对某一结点进行前插操作"><a href="#对某一结点进行前插操作" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>对某一结点进行前插操作</h4>
|
||
<p>前插通常为在某结点的前面插入一个新结点，后插则相反，且单链表插入算法中更常用后插操作</p>
|
||
<p>上述算法中，找到插入结点的前驱结点后再执行后插操作即可将前插操作转换为后插操作，前提是从单链表头结点开始顺序查找到其前驱结点，时间复杂度为$O(n)$</p>
|
||
<p>也可设待插入结点为*S, 将 *S插入到到 *P的前面，此时仍然可以将 *S插入到 *P后，将p->data与s->data交换，此时的时间复杂度为$O(1)$</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt">1
|
||
</span><span class="lnt">2
|
||
</span><span class="lnt">3
|
||
</span><span class="lnt">4
|
||
</span><span class="lnt">5
|
||
</span><span class="lnt">6
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="c1">//将 *S插入到到 *P的前面
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="n">s</span><span class="o">-></span><span class="n">next</span> <span class="o">=</span> <span class="n">p</span><span class="o">-></span><span class="n">next</span><span class="p">;</span> <span class="c1">//修改指针域
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="n">p</span><span class="o">-></span><span class="n">next</span> <span class="o">=</span> <span class="n">s</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"><span class="n">temp</span> <span class="o">=</span> <span class="n">p</span><span class="o">-></span><span class="n">data</span><span class="p">;</span> <span class="c1">//交换数据域
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="n">p</span><span class="o">-></span><span class="n">data</span> <span class="o">=</span> <span class="n">s</span><span class="o">-></span><span class="n">data</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"><span class="n">s</span><span class="o">-></span><span class="n">data</span> <span class="o">=</span> <span class="n">temp</span><span class="p">;</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><h4 id="删除结点操作"><a href="#删除结点操作" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>删除结点操作</h4>
|
||
<p>删除结点操作是江单链表的第i个结点删除。需要先检查删除位置的合法性，后查找表中第i-1个结点，即被删结点的前驱结点，再将其删除</p>
|
||
<p>假设*p为找到的被删结点的前驱结点，仅需修改 *p的指针域，即将 *p的指针域next指向 *q的下一结点</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt">1
|
||
</span><span class="lnt">2
|
||
</span><span class="lnt">3
|
||
</span><span class="lnt">4
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="n">p</span><span class="o">=</span><span class="nf">GetElem</span><span class="p">(</span><span class="n">L</span><span class="p">,</span><span class="n">i</span><span class="o">-</span><span class="mi">1</span><span class="p">);</span> <span class="c1">//查找删除位置的前驱结点
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="n">q</span><span class="o">=</span><span class="n">p</span><span class="o">-></span><span class="n">next</span><span class="p">;</span> <span class="c1">//和后继结点交换数据域
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="n">p</span><span class="o">-></span><span class="n">next</span><span class="o">=</span><span class="n">q</span><span class="o">-></span><span class="n">next</span><span class="p">;</span> <span class="c1">//将*q结点从链中断开
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="nf">free</span><span class="p">(</span><span class="n">q</span><span class="p">);</span> <span class="c1">//释放后继结点的存储空间
|
||
</span></span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><h4 id="求表长操作"><a href="#求表长操作" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>求表长操作</h4>
|
||
<p>即计算单链表中数据结点的个数，需从第一个结点开始顺序依次访问表中的每个结点，设置一个计算器变量，每访问一次结点则加一，直到访问空结点，算法复杂度为$O(n)$</p>
|
||
<p>单链表长度往往不包括头结点，对于不带头结点和带头结点的链表在求表长时操作存在不同。对于前者，当表空时需要单独处理</p>
|
||
<h3 id="双链表"><a href="#双链表" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>双链表</h3>
|
||
<p>双链表在单链表的结点中增加了一个指向前驱的prior指针，使得其无需像单链表那样只能从头开始依次顺序地向后遍历</p>
|
||
<p>结点类型描述：</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt">1
|
||
</span><span class="lnt">2
|
||
</span><span class="lnt">3
|
||
</span><span class="lnt">4
|
||
</span><span class="lnt">5
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="k">typedef</span> <span class="k">struct</span> <span class="n">DNode</span><span class="p">{</span> <span class="c1">//定义双链表结点类型
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">ElemType</span> <span class="n">data</span><span class="p">;</span> <span class="c1">// 数据域
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">struct</span> <span class="n">DNode</span> <span class="o">*</span><span class="n">prior</span><span class="p">,</span><span class="o">*</span><span class="n">next</span><span class="p">;</span> <span class="c1">//前驱和后驱结点
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
|
||
</span></span><span class="line"><span class="cl"><span class="p">}</span><span class="n">DNode</span><span class="p">,</span><span class="o">*</span><span class="n">DLinklist</span><span class="p">;</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><h4 id="双链表的插入操作"><a href="#双链表的插入操作" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>双链表的插入操作</h4>
|
||
<p>在双链表中p所指的结点之后插入结点*s</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt">1
|
||
</span><span class="lnt">2
|
||
</span><span class="lnt">3
|
||
</span><span class="lnt">4
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="n">s</span><span class="o">-></span><span class="n">next</span><span class="o">=</span><span class="n">p</span><span class="o">-></span><span class="n">next</span><span class="p">;</span> <span class="c1">//将结点*s插入到结点*p之后
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="n">p</span><span class="o">-></span><span class="n">next</span><span class="o">-></span><span class="n">prior</span><span class="o">=</span><span class="n">s</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"><span class="n">s</span><span class="o">-></span><span class="n">prior</span><span class="o">=</span><span class="n">p</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"><span class="n">p</span><span class="o">-></span><span class="n">next</span><span class="o">=</span><span class="n">s</span><span class="p">;</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><p>上述代码顺序并非唯一，但也不是任意的，第一二步需保证在第四步之前，当值丢失*p的后继结点的指针</p>
|
||
<h4 id="双链表的删除操作"><a href="#双链表的删除操作" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>双链表的删除操作</h4>
|
||
<p>删除双链表中结点*p的后继结点 *q</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt">1
|
||
</span><span class="lnt">2
|
||
</span><span class="lnt">3
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="n">p</span><span class="o">-></span><span class="n">next</span><span class="o">=</span><span class="n">q</span><span class="o">-></span><span class="n">next</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"><span class="n">q</span><span class="o">-></span><span class="n">next</span><span class="o">-></span><span class="n">prior</span><span class="o">=</span><span class="n">p</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"><span class="nf">free</span><span class="p">(</span><span class="n">q</span><span class="p">);</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><h3 id="循环链表"><a href="#循环链表" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>循环链表</h3>
|
||
<h4 id="循环单链表"><a href="#循环单链表" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>循环单链表</h4>
|
||
<p>循环单链表与单链表的区别在表中最后一个结点的指针不是NULL，而是指向头结点，从而整个链表形成一个环</p>
|
||
<p>循环单链表中，表尾结点*r的next域指向L，故表中没有指针域为NULL的结点，因此，循环单链表的判空条件为头结点的指针是否等于头指针</p>
|
||
<p>循环单链表中插入，删除与单链表一致，不同在于表尾操作时需要让单链表继续保持循环的性质。当然由于循环单链表往往认为是一个环，任何一个位置上的插入和删除操作都是等价，无需判断是否为表尾</p>
|
||
<p>相比于单链表，循环单链表能够从表中任意一个结点开始遍历整个链表，有时对单链表常做的操作是在表头和表尾进行，此时对循环单链表不设头指针，仅设尾指针能够有更高的效率,原因在于，若设的是头指针，对表尾进行操作需要$O(n)$的时间复杂度，若设的是尾指针r，r->即为头指针，对表头与表尾进行操作都只要$O(1)$的时间复杂度</p>
|
||
<h4 id="循环双链表"><a href="#循环双链表" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>循环双链表</h4>
|
||
<p>在循环双链表中，头结点的prior指针还要指向表尾结点</p>
|
||
<p>例如在循环双链表L中，某结点*p为尾结点时，p->next==L;当循环双链表为空表时，其头结点的prior域和next域都等于L</p>
|
||
<h3 id="静态链表"><a href="#静态链表" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>静态链表</h3>
|
||
<p>静态链表借助数组来描述线性表的链式存储结构，结点也有数据域data和指针域next，与先前的链表中的指针不同在于此处的指针是结点的相对地址(数组下标)，又称游标。和顺序表一致，静态链表也需要分配一块连续的内存空间</p>
|
||
<p>结构类型描述：</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt">1
|
||
</span><span class="lnt">2
|
||
</span><span class="lnt">3
|
||
</span><span class="lnt">4
|
||
</span><span class="lnt">5
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="cp">#define MaxSize 50
|
||
</span></span></span><span class="line"><span class="cl"><span class="cp"></span><span class="k">typedef</span> <span class="k">struct</span> <span class="p">{</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">ElemType</span> <span class="n">data</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="kt">int</span> <span class="n">next</span><span class="p">;</span><span class="c1">//下一个元素的数组下标
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">}</span> <span class="n">SLinkList</span><span class="p">[</span><span class="n">MaxSize</span><span class="p">];</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><p>静态链表以next == -1作为结束的标志。总体而言，静态链表不如单链表使用起来方便，但在一些不支持指针的高级语言中，其为一种巧妙的设计方法</p>
|
||
<h2 id="顺序表和链表的比较"><a href="#顺序表和链表的比较" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>顺序表和链表的比较</h2>
|
||
<h3 id="存取读写方式"><a href="#存取读写方式" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>存取(读写)方式</h3>
|
||
<p>顺序表可以顺序存取，也可以随机存取，链表只能从表头顺序存取元素。例如在第i个位置上执行存或取得操作，顺序表仅需一次访问，而链表则需从表头开始依次访问i次</p>
|
||
<h3 id="逻辑结构与物理结构"><a href="#逻辑结构与物理结构" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>逻辑结构与物理结构</h3>
|
||
<p>采用顺序存储是，逻辑上相邻的元素，对应的物理存储位置也相邻。采用链式存储时，逻辑上相邻的元素，物理存储位置不一定相邻，对应的逻辑关系是通过指针链接来表示的</p>
|
||
<h3 id="查找插入和删除操作"><a href="#查找插入和删除操作" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>查找、插入和删除操作</h3>
|
||
<p>对于按值查找，顺序表无序时，两者的时间复杂度均为$O(n)$;顺序表有序时，可采用折半查找，此时的时间复杂度为$O(\log_2 n)$</p>
|
||
<p>对于按序号查找，顺序表支持随机访问，时间复杂度仅为$O(1)$,而链表的平均时间复杂度为$O(n)$。顺序表的插入、删除操作，平均需要移动半个表长的元素。链表的插入、删除操作，只需修改相关结点的指针域即可。由于链表的每个结点都带有指针域，故而存储密度不够大</p>
|
||
<h3 id="空间分配"><a href="#空间分配" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>空间分配</h3>
|
||
<p>顺序存储在静态存储分配情形下，一旦存储空间装满就不能扩充，若再加入新元素，则会出现内存溢出，因此需要预先分配足够大的存储空间。预先分配过大，可能会导致顺序表后不大量闲置；预先分配过小则易发生溢出</p>
|
||
<p>动态分配情形下，虽然可以扩充存储空间，但需要移动大量元素，导致操作效率降低，若内存中没有更大块的连续存储空间，则会分配失败，链式存储的存储空间则只在需要时申请，只要空间足够就能够申请，操作灵活高效</p>
|
||
<h3 id="存储结构的选取考虑"><a href="#存储结构的选取考虑" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>存储结构的选取考虑</h3>
|
||
<h4 id="基于存储考虑"><a href="#基于存储考虑" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>基于存储考虑</h4>
|
||
<p>难以估计线性表长度或存储规模时，不宜采用顺序表；</p>
|
||
<p>链表不用事先估计存储规模，但链表的存储密度低(低于1)</p>
|
||
<h4 id="基于运算的考虑"><a href="#基于运算的考虑" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>基于运算的考虑</h4>
|
||
<p>在顺序表中按序号访问$a_j$的时间复杂度为$O(1)$，而链表中按序号访问的时间复杂度为$O(n)$,因此若经常做的运算是按序号访问数据元素，则显然顺序表优于链表</p>
|
||
<p>顺序表中插入，删除操作时，平均移动表中一半的元素，当数据元素的信息量较大且表较长时，此开销不可忽视；在链表中进行插入、删除操作时，虽然也要找插入位置，但主要进行的是比较操作，可见后者优于前者</p>
|
||
<h4 id="基于环境的考虑"><a href="#基于环境的考虑" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>基于环境的考虑</h4>
|
||
<p>顺序表易于实现，任何高级语言中都有数组类型；链表的操作是基于指针的，相对来讲，前者实现较为简单</p>
|
||
<p>两者各有优缺点，通常较稳定的线性表选择顺序存储，而频繁进行插入、删除操作的线性表宜使用链式存储</p>
|
||
<h3 id="一些练习-1"><a href="#一些练习-1" class="anchor-link"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon anchor-icon"><path d="M326.612 185.391c59.747 59.809 58.927 155.698.36 214.59-.11.12-.24.25-.36.37l-67.2 67.2c-59.27 59.27-155.699 59.262-214.96 0-59.27-59.26-59.27-155.7 0-214.96l37.106-37.106c9.84-9.84 26.786-3.3 27.294 10.606.648 17.722 3.826 35.527 9.69 52.721 1.986 5.822.567 12.262-3.783 16.612l-13.087 13.087c-28.026 28.026-28.905 73.66-1.155 101.96 28.024 28.579 74.086 28.749 102.325.51l67.2-67.19c28.191-28.191 28.073-73.757 0-101.83-3.701-3.694-7.429-6.564-10.341-8.569a16.037 16.037 0 0 1-6.947-12.606c-.396-10.567 3.348-21.456 11.698-29.806l21.054-21.055c5.521-5.521 14.182-6.199 20.584-1.731a152.482 152.482 0 0 1 20.522 17.197zM467.547 44.449c-59.261-59.262-155.69-59.27-214.96 0l-67.2 67.2c-.12.12-.25.25-.36.37-58.566 58.892-59.387 154.781.36 214.59a152.454 152.454 0 0 0 20.521 17.196c6.402 4.468 15.064 3.789 20.584-1.731l21.054-21.055c8.35-8.35 12.094-19.239 11.698-29.806a16.037 16.037 0 0 0-6.947-12.606c-2.912-2.005-6.64-4.875-10.341-8.569-28.073-28.073-28.191-73.639 0-101.83l67.2-67.19c28.239-28.239 74.3-28.069 102.325.51 27.75 28.3 26.872 73.934-1.155 101.96l-13.087 13.087c-4.35 4.35-5.769 10.79-3.783 16.612 5.864 17.194 9.042 34.999 9.69 52.721.509 13.906 17.454 20.446 27.294 10.606l37.106-37.106c59.271-59.259 59.271-155.699.001-214.959z"/></svg></a>一些练习</h3>
|
||
<ol>
|
||
<li>设计一个递归算法，删除不带头结点的单链表L中所有值为x的结点</li>
|
||
</ol>
|
||
<p>设计f(L,x)的功能是删除以L为收结点指针的单链表中所有值等于x的结点，显然有f(L->next,x)的功能是删除以L->next为首结点指针的单链表中所有值等于x的结点。由此，可以推出递归模型如下。</p>
|
||
<p>终止条件： f(L,x) = 不做任何事情； 若L为空表</p>
|
||
<p>递归主体： f(L,x) = 删除*L结点；f(L->next,x); 若L->data == x
|
||
f(L,x) = f(L->next,x); 其他情况</p>
|
||
<p>代码如下：</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
|
||
</span><span class="lnt"> 2
|
||
</span><span class="lnt"> 3
|
||
</span><span class="lnt"> 4
|
||
</span><span class="lnt"> 5
|
||
</span><span class="lnt"> 6
|
||
</span><span class="lnt"> 7
|
||
</span><span class="lnt"> 8
|
||
</span><span class="lnt"> 9
|
||
</span><span class="lnt">10
|
||
</span><span class="lnt">11
|
||
</span><span class="lnt">12
|
||
</span><span class="lnt">13
|
||
</span><span class="lnt">14
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="kt">void</span> <span class="nf">Del_X_3</span><span class="p">(</span><span class="n">Linklist</span> <span class="o">&</span><span class="n">L</span><span class="p">,</span><span class="n">ElemType</span> <span class="n">x</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="c1">//递归实现在单链表L中删除值为x的结点
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">LNode</span> <span class="o">*</span><span class="n">p</span><span class="p">;</span> <span class="c1">//p指向待删除结点
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">if</span><span class="p">(</span><span class="n">L</span><span class="o">==</span><span class="nb">NULL</span><span class="p">)</span> <span class="c1">//递归出口
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">return</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">if</span><span class="p">(</span><span class="n">L</span><span class="o">-></span><span class="n">data</span><span class="o">==</span><span class="n">x</span><span class="p">){</span> <span class="c1">//若L所指结点的值为x
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">p</span><span class="o">=</span><span class="n">L</span><span class="p">;</span> <span class="c1">//删除*L,并让L指向下一结点
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">L</span><span class="o">=</span><span class="n">L</span><span class="o">-></span><span class="n">next</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="nf">free</span><span class="p">(</span><span class="n">p</span><span class="p">);</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="nf">Del_X_3</span><span class="p">(</span><span class="n">L</span><span class="p">,</span><span class="n">x</span><span class="p">);</span> <span class="c1">//递归调用
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">else</span> <span class="c1">//若L所指结点的值不为x
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="nf">Del_X_3</span><span class="p">(</span><span class="n">L</span><span class="o">-></span><span class="n">next</span><span class="p">,</span><span class="n">x</span><span class="p">);</span><span class="c1">//递归调用
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">}</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><p>算法需要调用一个递归工作栈，深度为O(n),时间复杂度为O(n)。由于L为引用，是直接对原链表进行操作，因而不会发生断链</p>
|
||
<ol start="2">
|
||
<li>试L为带头结点的单链表，编写算法实现从尾到头反向输出每个结点的值</li>
|
||
</ol>
|
||
<p>算法思想：每当访问一个结点时，先递归输出它后面的结点，再输出该结点自身，这样链表就反向输出了</p>
|
||
<p>代码：</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
|
||
</span><span class="lnt"> 2
|
||
</span><span class="lnt"> 3
|
||
</span><span class="lnt"> 4
|
||
</span><span class="lnt"> 5
|
||
</span><span class="lnt"> 6
|
||
</span><span class="lnt"> 7
|
||
</span><span class="lnt"> 8
|
||
</span><span class="lnt"> 9
|
||
</span><span class="lnt">10
|
||
</span><span class="lnt">11
|
||
</span><span class="lnt">12
|
||
</span><span class="lnt">13
|
||
</span><span class="lnt">14
|
||
</span><span class="lnt">15
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="kt">void</span> <span class="nf">R_Print</span><span class="p">(</span><span class="n">LinkList</span> <span class="n">L</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="c1">//从尾到头输出单链表L中每个结点的值
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">if</span><span class="p">(</span><span class="n">L</span><span class="o">-></span><span class="n">next</span><span class="o">!=</span><span class="nb">NULL</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="nf">R_Print</span><span class="p">(</span><span class="n">L</span><span class="o">-></span><span class="n">next</span><span class="p">);</span> <span class="c1">//递归
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
|
||
</span></span><span class="line"><span class="cl"> <span class="p">}</span><span class="c1">//if
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">if</span><span class="p">(</span><span class="n">L</span><span class="o">!=</span><span class="nb">NULL</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="nf">print</span><span class="p">(</span><span class="n">L</span><span class="o">-></span><span class="n">data</span><span class="p">);</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"><span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"><span class="kt">void</span> <span class="nf">R_Ignore_Head</span><span class="p">(</span><span class="n">LinkList</span> <span class="n">L</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">if</span><span class="p">(</span><span class="n">L</span><span class="o">!=</span><span class="nb">NULL</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="nf">R_Print</span><span class="p">(</span><span class="n">L</span><span class="o">-></span><span class="n">next</span><span class="p">);</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"><span class="p">}</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><ol start="3">
|
||
<li>有一个带头结点的单链表L，试设计一个算法使其元素递增有序</li>
|
||
</ol>
|
||
<p>算法思想：</p>
|
||
<p>采用直接插入排序算法的思想，先构成只含一个数据结点的有序单链表，然后一次扫描单链表中剩下的结点*p(直到p==NULL为止)，在有序表中通过比较查找插入 *p的前驱结点 *pre,然后将 *p插入到 *pre之后</p>
|
||
<p>代码如下：</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
|
||
</span><span class="lnt"> 2
|
||
</span><span class="lnt"> 3
|
||
</span><span class="lnt"> 4
|
||
</span><span class="lnt"> 5
|
||
</span><span class="lnt"> 6
|
||
</span><span class="lnt"> 7
|
||
</span><span class="lnt"> 8
|
||
</span><span class="lnt"> 9
|
||
</span><span class="lnt">10
|
||
</span><span class="lnt">11
|
||
</span><span class="lnt">12
|
||
</span><span class="lnt">13
|
||
</span><span class="lnt">14
|
||
</span><span class="lnt">15
|
||
</span><span class="lnt">16
|
||
</span><span class="lnt">17
|
||
</span><span class="lnt">18
|
||
</span><span class="lnt">19
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="kt">void</span> <span class="nf">Sort</span><span class="p">(</span><span class="n">LinkList</span> <span class="o">&</span><span class="n">L</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="c1">//本算法实现将单链表L的结点重排，使其递增有序
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">LNode</span> <span class="o">*</span><span class="n">p</span><span class="o">=</span><span class="n">L</span><span class="o">-></span><span class="n">next</span><span class="p">,</span><span class="o">*</span><span class="n">pre</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">LNode</span> <span class="o">*</span><span class="n">r</span><span class="o">=</span><span class="n">p</span><span class="o">-></span><span class="n">next</span><span class="p">;</span> <span class="c1">//r保持*p后继结点指针，保证不断连
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">p</span><span class="o">-></span><span class="n">next</span> <span class="o">=</span> <span class="nb">NULL</span><span class="p">;</span> <span class="c1">//构造只含一个数据结点的有序表
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">p</span><span class="o">=</span><span class="n">r</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">while</span><span class="p">(</span><span class="n">p</span><span class="o">!=</span><span class="nb">NULL</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">r</span><span class="o">=</span><span class="n">p</span><span class="o">-></span><span class="n">next</span><span class="p">;</span> <span class="c1">//以保存*p的后继结点指针
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">pre</span><span class="o">=</span><span class="n">L</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">while</span><span class="p">(</span><span class="n">pre</span><span class="o">-></span><span class="n">next</span><span class="o">!=</span><span class="nb">NULL</span><span class="o">&&</span><span class="n">pre</span><span class="o">-></span><span class="n">next</span><span class="o">-></span><span class="n">data</span><span class="o"><</span><span class="n">p</span><span class="o">-></span><span class="n">data</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">pre</span> <span class="o">=</span> <span class="n">pre</span><span class="o">-></span><span class="n">next</span><span class="p">;</span> <span class="c1">//在有序表中查找插入*p的前驱结点*pre
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">p</span><span class="o">-></span><span class="n">next</span> <span class="o">=</span> <span class="n">pre</span><span class="o">-></span><span class="n">next</span><span class="p">;</span> <span class="c1">//将*p插入到*pre之后
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">pre</span><span class="o">-></span><span class="n">next</span> <span class="o">=</span> <span class="n">p</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">p</span><span class="o">=</span><span class="n">r</span><span class="p">;</span> <span class="c1">//扫描原单链表中剩下的结点
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
|
||
</span></span><span class="line"><span class="cl">
|
||
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"><span class="p">}</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><p>该算法的时间复杂度为$O(n^2)$，为达到最佳的时间性能，可将链表的数据复制到数组中，再采用时间复杂度为$O(n\log_2 n)$的排序算法进行排序，然后将数组元素依次插入链表中，此时的时间复杂度为$O(n\log_2 n)$，显然这是以空间换时间的策略</p>
|
||
<ol start="4">
|
||
<li>已知一个带有表头结点的单链表，结点结构为</li>
|
||
</ol>
|
||
<div class="table-container"><table>
|
||
<thead>
|
||
<tr>
|
||
<th style="text-align:center">data</th>
|
||
<th style="text-align:center">link</th>
|
||
</tr>
|
||
</thead>
|
||
</table></div>
|
||
<p>假设该链表只给出了头指针list。在不改变链表的前提下，请设计一个尽可能高效的算法，查找链表中倒数第k个位置上的结点(k为整数)。若查找成功，算法输出该结点的data域的值，并返回1；否则，只返回0，要求：</p>
|
||
<ol>
|
||
<li>描述算法的基本设计思想</li>
|
||
</ol>
|
||
<p>问题关键在于设计一个尽可能高效的算法，通过链表的一次遍历，找到倒数第k个结点的位置</p>
|
||
<p>算法的基本设计思想：</p>
|
||
<p>定义两个指针变量p和q，初始时均指向头结点的下一个结点(链表的第一个结点)，p指针沿链表移动，当p指针移动到第k个结点时，q指针开始与p指针同步移动；当p指针移动到最后一个结点时，q指针所指示结点为倒数第k个结点。以上过程对链表仅进行一遍扫描</p>
|
||
<ol start="2">
|
||
<li>
|
||
<p>描述算法的详细实现步骤</p>
|
||
<ol>
|
||
<li>count = 0，p和q指向链表表头结点的下一个结点</li>
|
||
<li>若p为空，转向步骤5</li>
|
||
<li>若count等于k，则q指向下一个结点，否则，count=count+1.</li>
|
||
<li>p指向下一个结点，转向步骤2</li>
|
||
<li>若count等于k，则查找成功，输出该结点的data域的值，返回1，否则，说明k值超过了线性表长度，查找失败，返回0</li>
|
||
<li>算法结束</li>
|
||
</ol>
|
||
</li>
|
||
<li>
|
||
<p>根据设计思想和实现步骤，采用程序设计语言描述算法，关键之处请给出简要注释</p>
|
||
</li>
|
||
</ol>
|
||
<p>算法实现：</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
|
||
</span><span class="lnt"> 2
|
||
</span><span class="lnt"> 3
|
||
</span><span class="lnt"> 4
|
||
</span><span class="lnt"> 5
|
||
</span><span class="lnt"> 6
|
||
</span><span class="lnt"> 7
|
||
</span><span class="lnt"> 8
|
||
</span><span class="lnt"> 9
|
||
</span><span class="lnt">10
|
||
</span><span class="lnt">11
|
||
</span><span class="lnt">12
|
||
</span><span class="lnt">13
|
||
</span><span class="lnt">14
|
||
</span><span class="lnt">15
|
||
</span><span class="lnt">16
|
||
</span><span class="lnt">17
|
||
</span><span class="lnt">18
|
||
</span><span class="lnt">19
|
||
</span><span class="lnt">20
|
||
</span><span class="lnt">21
|
||
</span><span class="lnt">22
|
||
</span><span class="lnt">23
|
||
</span><span class="lnt">24
|
||
</span><span class="lnt">25
|
||
</span><span class="lnt">26
|
||
</span><span class="lnt">27
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="k">typedef</span> <span class="kt">int</span> <span class="n">ElemType</span> <span class="c1">//链表数据的类型定义
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="k">typedef</span> <span class="k">struct</span> <span class="n">LNode</span><span class="p">{</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">ElemType</span> <span class="n">data</span><span class="p">;</span> <span class="c1">//结点数据
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">struct</span> <span class="n">LNode</span> <span class="o">*</span><span class="n">link</span><span class="p">;</span><span class="c1">//结点链接指针
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">}</span><span class="n">LNode</span><span class="p">,</span><span class="o">*</span><span class="n">LinkList</span><span class="p">;</span> <span class="c1">//链表结点的结构定义
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
|
||
</span></span><span class="line"><span class="cl"><span class="kt">int</span> <span class="nf">Search_k</span><span class="p">(</span><span class="n">LinkList</span> <span class="n">list</span><span class="p">,</span><span class="kt">int</span> <span class="n">k</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="c1">//查找链表list倒数第k个结点，并输出该结点data域的值
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">LNode</span> <span class="o">*</span><span class="n">p</span><span class="o">=</span><span class="n">list</span><span class="o">-></span><span class="n">link</span><span class="p">,</span><span class="o">*</span><span class="n">q</span><span class="o">=</span><span class="n">list</span><span class="o">-></span><span class="n">link</span><span class="p">;</span><span class="c1">//指针p，q指示第一个结点
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="kt">int</span> <span class="n">count</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">while</span><span class="p">(</span><span class="n">p</span><span class="o">!=</span><span class="nb">NULL</span><span class="p">){</span> <span class="c1">// 遍历链表直到最后一个结点
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">if</span><span class="p">(</span><span class="n">count</span><span class="o"><</span><span class="n">k</span><span class="p">){</span> <span class="c1">//计数，若count<k只移动p
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">count</span><span class="o">++</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">else</span><span class="p">{</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">q</span><span class="o">=</span><span class="n">q</span><span class="o">-></span><span class="n">link</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">p</span><span class="o">=</span><span class="n">p</span><span class="o">-></span><span class="n">link</span><span class="p">;</span> <span class="c1">//之后让p，q同步移动
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">if</span><span class="p">(</span><span class="n">count</span><span class="o"><</span><span class="n">k</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="mi">0</span><span class="p">;</span> <span class="c1">//查找失败返回0
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">else</span><span class="p">{</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="nf">printf</span><span class="p">(</span><span class="s">"%d"</span><span class="p">,</span><span class="n">q</span><span class="o">-></span><span class="n">data</span><span class="p">);</span> <span class="c1">//查找成功，打印并返回1
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">return</span> <span class="mi">1</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"><span class="p">}</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><ol start="5">
|
||
<li>设计一个算法完成以下功能：判断一个链表是否有环，如果有，找出环的入口点并返回，否则返回NULL</li>
|
||
</ol>
|
||
<p>算法的基本设计思想：</p>
|
||
<p>设置快慢两个指针分别为fast和slow，初始时都指向链表头head。slow每次走一步，即slow=slow->next;fast每次走两步，即fast=fast->next->next。由于fast比slow走得快，如果有环，那么fast一定会先进入，而slow后进入环，当两个指针都进入环后，经过若干操作后两个指针定能在环上相遇，从而判断一个链表是否存在环</p>
|
||
<p>当slow刚进入环时，fast早已进入环。因为fast每次比slow多走一步，且fast与slow 的距离小于环的长度，所以fast与slow相遇时，slow所走的距离不超过环的长度</p>
|
||
<p>设头结点到环的入口点的距离为a，环的入口点沿着环的方向到相遇点的距离为x，环长为r，相遇时fast绕过了n圈，则有2(a+x)=a+n * r+x,即a=n * r-x。显然从头结点到环的入口点的距离等于n被的环长减去环的入口点到相遇点的距离。因此可设置两个指针，一个指向head，一个指向相遇点，两个指针同步移动(一次走一步),相遇点即为环的入口点</p>
|
||
<p>代码实现：</p>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
|
||
</span><span class="lnt"> 2
|
||
</span><span class="lnt"> 3
|
||
</span><span class="lnt"> 4
|
||
</span><span class="lnt"> 5
|
||
</span><span class="lnt"> 6
|
||
</span><span class="lnt"> 7
|
||
</span><span class="lnt"> 8
|
||
</span><span class="lnt"> 9
|
||
</span><span class="lnt">10
|
||
</span><span class="lnt">11
|
||
</span><span class="lnt">12
|
||
</span><span class="lnt">13
|
||
</span><span class="lnt">14
|
||
</span><span class="lnt">15
|
||
</span><span class="lnt">16
|
||
</span><span class="lnt">17
|
||
</span><span class="lnt">18
|
||
</span><span class="lnt">19
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="n">LNode</span><span class="o">*</span> <span class="nf">FindLoopStart</span><span class="p">(</span><span class="n">LNode</span> <span class="o">*</span><span class="n">head</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">LNode</span> <span class="o">*</span><span class="n">fast</span><span class="o">=</span><span class="n">head</span><span class="p">,</span><span class="o">*</span><span class="n">slow</span><span class="o">=</span><span class="n">head</span><span class="p">;</span><span class="c1">//设置快慢两个指针
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">while</span><span class="p">(</span><span class="n">slow</span><span class="o">!=</span><span class="nb">NULL</span><span class="o">&&</span><span class="n">fats</span><span class="o">-></span><span class="n">next</span><span class="o">!=</span><span class="nb">NULL</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">slow</span><span class="o">=</span><span class="n">slow</span><span class="o">-></span><span class="n">next</span><span class="p">;</span> <span class="c1">//每次走一步
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">fast</span><span class="o">=</span><span class="n">fast</span><span class="o">-></span><span class="n">next</span><span class="o">-</span><span class="n">next</span><span class="p">;</span><span class="c1">//每次走两步
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">if</span><span class="p">(</span><span class="n">slow</span><span class="o">==</span><span class="n">fast</span><span class="p">){</span> <span class="c1">// 相遇
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">break</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">if</span><span class="p">(</span><span class="n">slow</span><span class="o">==</span><span class="nb">NULL</span><span class="o">||</span><span class="n">fast</span><span class="o">-></span><span class="n">next</span><span class="o">==</span><span class="nb">NULL</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nb">NULL</span><span class="p">;</span> <span class="c1">//没有环，返回NULL
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">LNode</span> <span class="o">*</span><span class="n">p1</span><span class="o">=</span><span class="n">head</span><span class="p">,</span><span class="o">*</span><span class="n">p2</span><span class="o">=</span><span class="n">slow</span><span class="p">;</span> <span class="c1">//分别指向开始点，相遇点
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">while</span><span class="p">(</span><span class="n">p1</span><span class="o">!=</span><span class="n">p2</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">p1</span><span class="o">=</span><span class="n">p1</span><span class="o">-></span><span class="n">next</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">p2</span><span class="o">=</span><span class="n">p2</span><span class="o">-></span><span class="n">next</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="n">p1</span><span class="p">;</span> <span class="c1">//返回入口点
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">}</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><ol start="6">
|
||
<li>设线性表$L=(a_1,a_2,a_3,\cdots,a_{n-2},a_{n-1},a_{n})$采用带头结点的单链表保存，链表中的结点定义如下：</li>
|
||
</ol>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt">1
|
||
</span><span class="lnt">2
|
||
</span><span class="lnt">3
|
||
</span><span class="lnt">4
|
||
</span><span class="lnt">5
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="k">typedef</span> <span class="k">struct</span> <span class="n">node</span>
|
||
</span></span><span class="line"><span class="cl"><span class="p">{</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="kt">int</span> <span class="n">data</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">struct</span> <span class="n">node</span><span class="o">*</span><span class="n">next</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"><span class="p">}</span><span class="n">NODE</span><span class="p">;</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><p>请设计一个空间复杂度为$O(1)$且时间上尽可能高效的算法，重新排列L中的各结点，得到线性表$L_1=(a_1,a_n,a_2,a_{n-1},a_3,a_{n-2},\cdots)$。要求：</p>
|
||
<ol>
|
||
<li>描述算法的基本设计思想和详细实现步骤</li>
|
||
</ol>
|
||
<p>观察比较$L$和$L_1$可知，后者由前者摘取一个元素，再摘取倒数第一个元素，依次合并而成</p>
|
||
<p>为了方便链表后半段取元素，需要先将$L$的后半段原地逆置(题目要求空间复杂度为$O(n)$因而不能借助栈来逆置)，否则每取最后一个结点都需要遍历一次链表</p>
|
||
<pre><code>1. 先找出链表L的中间结点，为此设置两个指针p和q，指针p每次走一步，指针q每次走两步，当指针q到达链尾时，指针p正好在链表的中间结点
|
||
2. 然后将L的后半段结点原地逆置
|
||
3. 从单链表前后两段中依次各取一个结点，按要求重排
|
||
</code></pre>
|
||
<ol start="2">
|
||
<li>根据设计思想和实现步骤，采用程序设计预言描述算法，关键之处请给出简要注释</li>
|
||
</ol>
|
||
<div class="highlight"><div class="chroma">
|
||
<div class="table-container"><table class="lntable"><tr><td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code><span class="lnt"> 1
|
||
</span><span class="lnt"> 2
|
||
</span><span class="lnt"> 3
|
||
</span><span class="lnt"> 4
|
||
</span><span class="lnt"> 5
|
||
</span><span class="lnt"> 6
|
||
</span><span class="lnt"> 7
|
||
</span><span class="lnt"> 8
|
||
</span><span class="lnt"> 9
|
||
</span><span class="lnt">10
|
||
</span><span class="lnt">11
|
||
</span><span class="lnt">12
|
||
</span><span class="lnt">13
|
||
</span><span class="lnt">14
|
||
</span><span class="lnt">15
|
||
</span><span class="lnt">16
|
||
</span><span class="lnt">17
|
||
</span><span class="lnt">18
|
||
</span><span class="lnt">19
|
||
</span><span class="lnt">20
|
||
</span><span class="lnt">21
|
||
</span><span class="lnt">22
|
||
</span><span class="lnt">23
|
||
</span><span class="lnt">24
|
||
</span><span class="lnt">25
|
||
</span><span class="lnt">26
|
||
</span><span class="lnt">27
|
||
</span><span class="lnt">28
|
||
</span><span class="lnt">29
|
||
</span><span class="lnt">30
|
||
</span></code></pre></td>
|
||
<td class="lntd">
|
||
<pre tabindex="0" class="chroma"><code class="language-c" data-lang="c"><span class="line"><span class="cl"><span class="kt">void</span> <span class="nf">change_list</span><span class="p">(</span><span class="n">NODE</span><span class="o">*</span><span class="n">h</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">NODE</span> <span class="o">*</span><span class="n">p</span><span class="p">,</span><span class="o">*</span><span class="n">q</span><span class="p">,</span><span class="o">*</span><span class="n">r</span><span class="p">,</span><span class="o">*</span><span class="n">s</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">p</span><span class="o">=</span><span class="n">q</span><span class="o">=</span><span class="n">h</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">while</span><span class="p">(</span><span class="n">q</span><span class="o">-></span><span class="n">next</span><span class="o">!=</span><span class="nb">NULL</span><span class="p">){</span> <span class="c1">//寻找中间结点
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">p</span><span class="o">=</span><span class="n">p</span><span class="o">-></span><span class="n">next</span><span class="p">;</span> <span class="c1">//p走一步
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">q</span><span class="o">=</span><span class="n">q</span><span class="o">-></span><span class="n">next</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">if</span><span class="p">(</span><span class="n">q</span><span class="o">-></span><span class="n">next</span><span class="o">!=</span><span class="nb">NULL</span><span class="p">){</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">q</span><span class="o">=</span><span class="n">q</span><span class="o">-></span><span class="n">next</span><span class="p">;</span> <span class="c1">//q走两步
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">q</span><span class="o">=</span><span class="n">p</span><span class="o">-></span><span class="n">next</span><span class="p">;</span> <span class="c1">//p所指结点为中间结点，q为后半段链表的首结点
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">p</span><span class="o">-></span><span class="n">next</span><span class="o">=</span><span class="nb">NULL</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">while</span><span class="p">(</span><span class="n">q</span><span class="o">!=</span><span class="nb">NULL</span><span class="p">){</span> <span class="c1">//逆置链表后半段
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">r</span><span class="o">=</span><span class="n">q</span><span class="o">-></span><span class="n">next</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">q</span><span class="o">-></span><span class="n">next</span><span class="o">=</span><span class="n">p</span><span class="o">-></span><span class="n">next</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">p</span><span class="o">-></span><span class="n">next</span><span class="o">=</span><span class="n">q</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">q</span><span class="o">=</span><span class="n">r</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl">
|
||
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">s</span><span class="o">=</span><span class="n">h</span><span class="o">-></span><span class="n">next</span><span class="p">;</span> <span class="c1">//s指向前半段的第一个数据结点，插入点
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">q</span><span class="o">=</span><span class="n">p</span><span class="o">-></span><span class="n">next</span><span class="p">;</span> <span class="c1">//q指向后半段的第一个数据结点
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">p</span><span class="o">-></span><span class="n">next</span><span class="o">=</span><span class="nb">NULL</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="k">while</span><span class="p">(</span><span class="n">q</span><span class="o">!=</span><span class="nb">NULL</span><span class="p">){</span> <span class="c1">//将链表后半段的结点插入到指定位置
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">r</span><span class="o">=</span><span class="n">q</span><span class="o">-></span><span class="n">next</span><span class="p">;</span> <span class="c1">//r指向后半段的下一个结点
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">q</span><span class="o">-></span><span class="n">next</span><span class="o">=</span><span class="n">s</span><span class="o">-></span><span class="n">next</span><span class="p">;</span> <span class="c1">//将q所指结点插入到s所指结点之后
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">s</span><span class="o">-></span><span class="n">next</span><span class="o">=</span><span class="n">q</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="n">s</span><span class="o">=</span><span class="n">q</span><span class="o">-></span><span class="n">next</span><span class="p">;</span> <span class="c1">//s指向前半段的额下一个插入点
|
||
</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="n">q</span><span class="o">=</span><span class="n">r</span><span class="p">;</span>
|
||
</span></span><span class="line"><span class="cl"> <span class="p">}</span>
|
||
</span></span><span class="line"><span class="cl"><span class="p">}</span>
|
||
</span></span></code></pre></td></tr></table></div>
|
||
</div>
|
||
</div><ol start="3">
|
||
<li>计算时间复杂度</li>
|
||
</ol>
|
||
<p>第一步中找中间结点的时间复杂度为$O(n)$,第二步逆置的时间复杂度为$O(n)$，第三部合并链表的时间复杂度为$O(n)$，因此该算法的时间复杂度为$O(n)$</p>
|
||
|
||
</div>
|
||
|
||
|
||
|
||
|
||
</article>
|
||
|
||
|
||
|
||
|
||
<div class="updated-badge-container">
|
||
<span title="Updated @ 2023-06-18 21:19:01 CST" style="cursor:help">
|
||
|
||
<svg xmlns="http://www.w3.org/2000/svg" width="130" height="20" class="updated-badge"><linearGradient id="b" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="a"><rect width="130" height="20" rx="3" fill="#fff"/></clipPath><g clip-path="url(#a)"><path class="updated-badge-left" d="M0 0h55v20H0z"/><path class="updated-badge-right" d="M55 0h75v20H55z"/><path fill="url(#b)" d="M0 0h130v20H0z"/></g><g fill="#fff" text-anchor="middle" font-size="110"><text x="285" y="150" fill="#010101" fill-opacity=".3" textLength="450" transform="scale(.1)">updated</text><text x="285" y="140" textLength="450" transform="scale(.1)">updated</text><text x="915" y="150" fill="#010101" fill-opacity=".3" textLength="650" transform="scale(.1)">2023-06-18</text><text x="915" y="140" textLength="650" transform="scale(.1)">2023-06-18</text></g></svg>
|
||
</span></div>
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
<ul class="post-nav">
|
||
|
||
<li class="post-nav-prev">
|
||
<a href="/408/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E5%8F%91%E5%B1%95%E5%8E%86%E7%A8%8B/" rel="prev">< 《操作系统》操作系统发展历程</a>
|
||
</li>
|
||
|
||
|
||
<li class="post-nav-next">
|
||
<a href="/408/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E7%9A%84%E5%9F%BA%E6%9C%AC%E6%A6%82%E5%BF%B5/" rel="next">《操作系统》操作系统的基本概念 ></a>
|
||
</li>
|
||
|
||
</ul>
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
</div>
|
||
</main>
|
||
|
||
|
||
|
||
<div id="back-to-top" class="back-to-top">
|
||
<a href="#"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 448 512" class="icon arrow-up"><path d="M34.9 289.5l-22.2-22.2c-9.4-9.4-9.4-24.6 0-33.9L207 39c9.4-9.4 24.6-9.4 33.9 0l194.3 194.3c9.4 9.4 9.4 24.6 0 33.9L413 289.4c-9.5 9.5-25 9.3-34.3-.4L264 168.6V456c0 13.3-10.7 24-24 24h-32c-13.3 0-24-10.7-24-24V168.6L69.2 289.1c-9.3 9.8-24.8 10-34.3.4z"/></svg></a>
|
||
</div>
|
||
|
||
|
||
|
||
<footer id="footer" class="footer">
|
||
<div class="footer-inner">
|
||
<div class="site-info">© 2022–2023 <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon footer-icon"><path d="M462.3 62.6C407.5 15.9 326 24.3 275.7 76.2L256 96.5l-19.7-20.3C186.1 24.3 104.5 15.9 49.7 62.6c-62.8 53.6-66.1 149.8-9.9 207.9l193.5 199.8c12.5 12.9 32.8 12.9 45.3 0l193.5-199.8c56.3-58.1 53-154.3-9.8-207.9z"/></svg> InkSoul</div><div class="powered-by">Powered by <a href="https://github.com/gohugoio/hugo" target="_blank" rel="noopener">Hugo</a> | Theme is <a href="https://github.com/reuixiy/hugo-theme-meme" target="_blank" rel="noopener">MemE</a></div><div class="site-copyright"><a href="https://creativecommons.org/licenses/by-nc-sa/4.0/deed.zh" target="_blank" rel="noopener">CC BY-NC-SA 4.0</a></div><div class="custom-footer"><a href="https://beian.miit.gov.cn" target="_blank" rel="noopener">闽ICP备2022009452号-1</a></div>
|
||
|
||
|
||
|
||
<ul class="socials"><li class="socials-item">
|
||
<a href="mailto:qingci30@163.com" target="_blank" rel="external noopener" title="Email"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" class="icon social-icon"><path d="M464 64H48C21.49 64 0 85.49 0 112v288c0 26.51 21.49 48 48 48h416c26.51 0 48-21.49 48-48V112c0-26.51-21.49-48-48-48zm0 48v40.805c-22.422 18.259-58.168 46.651-134.587 106.49-16.841 13.247-50.201 45.072-73.413 44.701-23.208.375-56.579-31.459-73.413-44.701C106.18 199.465 70.425 171.067 48 152.805V112h416zM48 400V214.398c22.914 18.251 55.409 43.862 104.938 82.646 21.857 17.205 60.134 55.186 103.062 54.955 42.717.231 80.509-37.199 103.053-54.947 49.528-38.783 82.032-64.401 104.947-82.653V400H48z"/></svg></a>
|
||
</li><li class="socials-item">
|
||
<a href="https://github.com/ink-soul" target="_blank" rel="external noopener" title="GitHub"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" class="icon social-icon"><path d="M12 .297c-6.63 0-12 5.373-12 12 0 5.303 3.438 9.8 8.205 11.385.6.113.82-.258.82-.577 0-.285-.01-1.04-.015-2.04-3.338.724-4.042-1.61-4.042-1.61C4.422 18.07 3.633 17.7 3.633 17.7c-1.087-.744.084-.729.084-.729 1.205.084 1.838 1.236 1.838 1.236 1.07 1.835 2.809 1.305 3.495.998.108-.776.417-1.305.76-1.605-2.665-.3-5.466-1.332-5.466-5.93 0-1.31.465-2.38 1.235-3.22-.135-.303-.54-1.523.105-3.176 0 0 1.005-.322 3.3 1.23.96-.267 1.98-.399 3-.405 1.02.006 2.04.138 3 .405 2.28-1.552 3.285-1.23 3.285-1.23.645 1.653.24 2.873.12 3.176.765.84 1.23 1.91 1.23 3.22 0 4.61-2.805 5.625-5.475 5.92.42.36.81 1.096.81 2.22 0 1.606-.015 2.896-.015 3.286 0 .315.21.69.825.57C20.565 22.092 24 17.592 24 12.297c0-6.627-5.373-12-12-12"/></svg></a>
|
||
</li><li class="socials-item">
|
||
<a href="http://gitea.inksoul.top/inksoul" target="_blank" rel="external noopener" title="gitea"><svg class="icon social-icon" fill="none" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path d="M4.209 4.603c-.247 0-.525.02-.84.088-.333.07-1.28.283-2.054 1.027C-.403 7.25.035 9.685.089 10.052c.065.446.263 1.687 1.21 2.768 1.749 2.141 5.513 2.092 5.513 2.092s.462 1.103 1.168 2.119c.955 1.263 1.936 2.248 2.89 2.367 2.406 0 7.212-.004 7.212-.004s.458.004 1.08-.394c.535-.324 1.013-.893 1.013-.893s.492-.527 1.18-1.73c.21-.37.385-.729.538-1.068 0 0 2.107-4.471 2.107-8.823-.042-1.318-.367-1.55-.443-1.627-.156-.156-.366-.153-.366-.153s-4.475.252-6.792.306c-.508.011-1.012.023-1.512.027v4.474l-.634-.301c0-1.39-.004-4.17-.004-4.17-1.107.016-3.405-.084-3.405-.084s-5.399-.27-5.987-.324c-.187-.011-.401-.032-.648-.032zm.354 1.832h.111s.271 2.269.6 3.597C5.549 11.147 6.22 13 6.22 13s-.996-.119-1.641-.348c-.99-.324-1.409-.714-1.409-.714s-.73-.511-1.096-1.52C1.444 8.73 2.021 7.7 2.021 7.7s.32-.859 1.47-1.145c.395-.106.863-.12 1.072-.12zm8.33 2.554c.26.003.509.127.509.127l.868.422-.529 1.075a.686.686 0 0 0-.614.359.685.685 0 0 0 .072.756l-.939 1.924a.69.69 0 0 0-.66.527.687.687 0 0 0 .347.763.686.686 0 0 0 .867-.206.688.688 0 0 0-.069-.882l.916-1.874a.667.667 0 0 0 .237-.02.657.657 0 0 0 .271-.137 8.826 8.826 0 0 1 1.016.512.761.761 0 0 1 .286.282c.073.21-.073.569-.073.569-.087.29-.702 1.55-.702 1.55a.692.692 0 0 0-.676.477.681.681 0 1 0 1.157-.252c.073-.141.141-.282.214-.431.19-.397.515-1.16.515-1.16.035-.066.218-.394.103-.814-.095-.435-.48-.638-.48-.638-.467-.301-1.116-.58-1.116-.58s0-.156-.042-.27a.688.688 0 0 0-.148-.241l.516-1.062 2.89 1.401s.48.218.583.619c.073.282-.019.534-.069.657-.24.587-2.1 4.317-2.1 4.317s-.232.554-.748.588a1.065 1.065 0 0 1-.393-.045l-.202-.08-4.31-2.1s-.417-.218-.49-.596c-.083-.31.104-.691.104-.691l2.073-4.272s.183-.37.466-.497a.855.855 0 0 1 .35-.077z" ></path></svg></a>
|
||
</li><li class="socials-item">
|
||
<a href="https://space.bilibili.com/262369930" target="_blank" rel="external noopener" title="bilibili"><svg class="icon social-icon" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path d="M17.813 4.653h.854c1.51.054 2.769.578 3.773 1.574 1.004.995 1.524 2.249 1.56 3.76v7.36c-.036 1.51-.556 2.769-1.56 3.773s-2.262 1.524-3.773 1.56H5.333c-1.51-.036-2.769-.556-3.773-1.56S.036 18.858 0 17.347v-7.36c.036-1.511.556-2.765 1.56-3.76 1.004-.996 2.262-1.52 3.773-1.574h.774l-1.174-1.12a1.234 1.234 0 0 1-.373-.906c0-.356.124-.658.373-.907l.027-.027c.267-.249.573-.373.92-.373.347 0 .653.124.92.373L9.653 4.44c.071.071.134.142.187.213h4.267a.836.836 0 0 1 .16-.213l2.853-2.747c.267-.249.573-.373.92-.373.347 0 .662.151.929.4.267.249.391.551.391.907 0 .355-.124.657-.373.906zM5.333 7.24c-.746.018-1.373.276-1.88.773-.506.498-.769 1.13-.786 1.894v7.52c.017.764.28 1.395.786 1.893.507.498 1.134.756 1.88.773h13.334c.746-.017 1.373-.275 1.88-.773.506-.498.769-1.129.786-1.893v-7.52c-.017-.765-.28-1.396-.786-1.894-.507-.497-1.134-.755-1.88-.773zM8 11.107c.373 0 .684.124.933.373.25.249.383.569.4.96v1.173c-.017.391-.15.711-.4.96-.249.25-.56.374-.933.374s-.684-.125-.933-.374c-.25-.249-.383-.569-.4-.96V12.44c0-.373.129-.689.386-.947.258-.257.574-.386.947-.386zm8 0c.373 0 .684.124.933.373.25.249.383.569.4.96v1.173c-.017.391-.15.711-.4.96-.249.25-.56.374-.933.374s-.684-.125-.933-.374c-.25-.249-.383-.569-.4-.96V12.44c.017-.391.15-.711.4-.96.249-.249.56-.373.933-.373Z"/></svg></a>
|
||
</li></ul>
|
||
|
||
|
||
|
||
|
||
|
||
</div>
|
||
</footer>
|
||
|
||
|
||
</div>
|
||
<script>
|
||
if ('serviceWorker' in navigator) {
|
||
window.addEventListener('load', function() {
|
||
navigator.serviceWorker.register('\/sw.js');
|
||
});
|
||
}
|
||
</script>
|
||
|
||
|
||
|
||
<link rel="stylesheet" href="https://fastly.jsdelivr.net/npm/katex@0.13.0/dist/katex.min.css" integrity="sha256-gPJfuwTULrEAAcI3X4bALVU/2qBU+QY/TpoD3GO+Exw=" crossorigin="anonymous">
|
||
|
||
<script>
|
||
if (typeof renderMathInElement === 'undefined') {
|
||
var getScript = (options) => {
|
||
var script = document.createElement('script');
|
||
script.defer = true;
|
||
script.crossOrigin = 'anonymous';
|
||
Object.keys(options).forEach((key) => {
|
||
script[key] = options[key];
|
||
});
|
||
document.body.appendChild(script);
|
||
};
|
||
getScript({
|
||
src: 'https:\/\/fastly.jsdelivr.net/npm/katex@0.13.0/dist/katex.min.js',
|
||
integrity: 'sha256-YTW9cMncW/ZQMhY69KaUxIa2cPTxV87Uh627Gf5ODUw=',
|
||
onload: () => {
|
||
getScript({
|
||
src: 'https:\/\/fastly.jsdelivr.net/npm/katex@0.13.0/dist/contrib/mhchem.min.js',
|
||
integrity: 'sha256-yzSfYeVsWJ1x+2g8CYHsB/Mn7PcSp8122k5BM4T3Vxw=',
|
||
onload: () => {
|
||
getScript({
|
||
src: 'https:\/\/fastly.jsdelivr.net/npm/katex@0.13.0/dist/contrib/auto-render.min.js',
|
||
integrity: 'sha256-fxJzNV6hpc8tgW8tF0zVobKa71eTCRGTgxFXt1ZpJNM=',
|
||
onload: () => {
|
||
renderKaTex();
|
||
}
|
||
});
|
||
}
|
||
});
|
||
}
|
||
});
|
||
} else {
|
||
renderKaTex();
|
||
}
|
||
function renderKaTex() {
|
||
renderMathInElement(
|
||
document.body,
|
||
{
|
||
delimiters: [
|
||
{left: "$$", right: "$$", display: true},
|
||
{left: "\\[", right: "\\]", display: true},
|
||
{left: "$", right: "$", display: false},
|
||
{left: "\\(", right: "\\)", display: false}
|
||
]
|
||
}
|
||
);
|
||
}
|
||
</script>
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
<script src="https://fastly.jsdelivr.net/npm/medium-zoom@latest/dist/medium-zoom.min.js"></script>
|
||
|
||
<script>
|
||
let imgNodes = document.querySelectorAll('div.post-body img');
|
||
imgNodes = Array.from(imgNodes).filter(node => node.parentNode.tagName !== "A");
|
||
|
||
mediumZoom(imgNodes, {
|
||
background: 'hsla(var(--color-bg-h), var(--color-bg-s), var(--color-bg-l), 0.95)'
|
||
})
|
||
</script>
|
||
|
||
|
||
|
||
|
||
<script src="https://fastly.jsdelivr.net/npm/instant.page@5.1.0/instantpage.min.js" type="module" defer></script>
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
</body>
|
||
</html>
|