线性表

（一）基本特点：最基本、最简单、最常用的一种数据结构

在这种结构中：

1.存在一个唯一的被称为“第一个”的数据元素；

2.存在一个唯一的被称为“最后一个”的数据元素；

3.除第一个元素外，每个元素均有唯一一个直接前驱；

4.除最后一个元素外，每个元素均有唯一一个直接后继。

（二）定义：

线性表(Linear List) ：是由n(n≧0)个数据元素(结点)a1，a2， …an组成的有限序列。该序列中的所有结点具有相同的数据类型。其中数据元素的个数n称为线性表的长度。

当n=0时，称为空表。

当n>0时，将非空的线性表记作： (a1，a2，…an)

a1称为线性表的第一个(首)结点，an称为线性表的最后一个(尾)结点。

（三）线性表顺序存储 ：把线性表的结点按逻辑顺序依次存放在一组地址连续的存储单元里。用这种方法存储的线性表简称顺序表。

顺序存储的线性表的特点：

1.线性表的逻辑顺序与物理顺序一致；

2.数据元素之间的关系是以元素在计算机内“物理位置相邻”来体现。

线性表中的顺序表的PHP实现

  1. <?php
  2.  
  3. /**
  4.  
  5. * 顺序表基本操作
  6.  
  7. *
  8.  
  9. *包括
  10.  
  11. *1.顺序表的初始化 __contruct()
  12.  
  13. *2.清空顺序表 __destruct()
  14.  
  15. *3.判断顺序表是否为空 isEmpty()
  16.  
  17. *4.返回顺序表的长度 getLength()
  18.  
  19. *5.根据下标返回顺序表中的某个元素 getElement()
  20.  
  21. *6.返回顺序表中某个元素的位置 getElementPosition()
  22.  
  23. *7.返回顺序表中某个元素的直接前驱元素 getElementPredecessorr()
  24.  
  25. *8.返回某个元素的直接后继元素 getElementSubsequence()
  26.  
  27. *9.指定下标位置返回元素 getElemForPos()
  28.  
  29. *10.根据下标或者元素值删除顺序表中的某个元素 getDeleteElement()
  30.  
  31. *11.根据元素位置删除顺序表中的某个元素 getDeleteEleForPos()
  32.  
  33. *12.在指定位置插入一个新的结点 getInsertElement()
  34.  
  35. */
  36.  
  37. header("content-type:text/html;charset=utf-8");
  38.  
  39. class OrderLinearList{
  40.  
  41. public $oll;//顺序表
  42.  
  43. /**
  44.  
  45. * 顺序表初始化
  46.  
  47. *
  48.  
  49. * @param mixed $oll
  50.  
  51. * @return void
  52.  
  53. * */
  54.  
  55. public function __construct($oll=array()){
  56.  
  57. $this->oll=$oll;
  58.  
  59. }
  60.  
  61. /**
  62.  
  63. * 清空顺序表
  64.  
  65. *@return void
  66.  
  67. */
  68.  
  69. public function __destruct(){
  70.  
  71. foreach($this->oll as $key=>$value){
  72.  
  73. unset($this->oll[$key]);
  74.  
  75. }
  76.  
  77. }
  78.  
  79. /**
  80.  
  81. * 判断顺序表是否为空
  82.  
  83. * @return boolean 为空返回true,否则返回false
  84.  
  85. * */
  86.  
  87. public function isEmpty(){
  88.  
  89. if(count($this->oll) > 0){
  90.  
  91. return false;
  92.  
  93. }else{
  94.  
  95. return true;
  96.  
  97. }
  98.  
  99. }
  100.  
  101. /**
  102.  
  103. * 返回顺序表的长度
  104.  
  105. * @return int
  106.  
  107. * */
  108.  
  109. public function getLength(){
  110.  
  111. return count($this->oll);
  112.  
  113. }
  114.  
  115. /**
  116.  
  117. * 返回顺序表中下标为$key的元素
  118.  
  119. *
  120.  
  121. * @param mixed $key 顺序表元素的下标
  122.  
  123. * @return mixed
  124.  
  125. * */
  126.  
  127. public function getElement($key){
  128.  
  129. return $this->oll[$key];
  130.  
  131. }
  132.  
  133. /**
  134.  
  135. * 返回顺序表中某个元素的位置
  136.  
  137. *
  138.  
  139. * @param mixed $value 顺序表中某个元素的值
  140.  
  141. * @return int 从1开始,如果返回-1表示不存在该元素
  142.  
  143. * */
  144.  
  145. public function getElementPosition($value){
  146.  
  147. $i=0;
  148.  
  149. foreach($this->oll as $val){
  150.  
  151. $i++;
  152.  
  153. if(strcmp($value,$val) === 0){
  154.  
  155. return $i;
  156.  
  157. }
  158.  
  159. }
  160.  
  161. return -1;
  162.  
  163. }
  164.  
  165. /**
  166.  
  167. * 返回顺序表中某个元素的直接前驱元素
  168.  
  169. *
  170.  
  171. *@param mixed $value顺序表中某个元素的值
  172.  
  173. *@param bool $tag 如果$value为下标则为1,如果$value为元素值则为2
  174.  
  175. *@return array array('value'=>...)直接前驱元素值，array('key'=>...)直接前驱元素下标
  176.  
  177. **/
  178.  
  179. public function getElementPredecessorr($value,$tag=1){
  180.  
  181. $i=0;
  182.  
  183. foreach($this->oll as $key=>$val){
  184.  
  185. $i++;
  186.  
  187. if($tag ==1 ){
  188.  
  189. if(strcmp($key,$value) === 0){
  190.  
  191. if($i == 1){
  192.  
  193. return false;
  194.  
  195. }
  196.  
  197. prev($this->oll);
  198.  
  199. prev($this->oll);
  200.  
  201. return array('value'=>current($this->oll),'key'=>key($this->oll));
  202.  
  203. }
  204.  
  205. }
  206.  
  207. if($tag == 2){
  208.  
  209. if(strcmp($val,$value) === 0){
  210.  
  211. if($i == 1){
  212.  
  213. return false;
  214.  
  215. }
  216.  
  217. prev($this->oll);
  218.  
  219. prev($this->oll);
  220.  
  221. return array('value'=>current($this->oll),'key'=>key($this->oll));
  222.  
  223. }
  224.  
  225. }
  226.  
  227. }
  228.  
  229. }
  230.  
  231. /**
  232.  
  233. * 返回某个元素的直接后继元素
  234.  
  235. *
  236.  
  237. *@param mixed $value顺序表中某个元素的值
  238.  
  239. *@param bool $tag 如果$value为下标则为1,如果$value为元素值则为2
  240.  
  241. *@return array array('value'=>...)直接后继元素值，array('key'=>...)直接后继元素下标
  242.  
  243. **/
  244.  
  245. public function getElementSubsequence($value,$tag=1){
  246.  
  247. $i=0;
  248.  
  249. $len=count($this->oll);
  250.  
  251. foreach($this->oll as $key=>$val){
  252.  
  253. $i++;
  254.  
  255. if($tag ==1 ){
  256.  
  257. if(strcmp($key,$value) == 0){
  258.  
  259. if($i == $len){
  260.  
  261. return false;
  262.  
  263. }
  264.  
  265. return array('value'=>current($this->oll),'key'=>key($this->oll));
  266.  
  267. }
  268.  
  269. }
  270.  
  271. if($tag == 2){
  272.  
  273. if(strcmp($val,$value) == 0){
  274.  
  275. if($i == $len){
  276.  
  277. return false;
  278.  
  279. }
  280.  
  281. return array('value'=>current($this->oll),'key'=>ke
  282.  
  283. y($this->oll));
  284.  
  285. }
  286.  
  287. }
  288.  
  289. }
  290.  
  291. return false;
  292.  
  293. }
  294.  
  295. /**
  296.  
  297. * 在指定位置插入一个新的结点
  298.  
  299. *
  300.  
  301. * @param mixed $p 新结点插入位置,从1开始
  302.  
  303. * @param mixed $value 顺序表新结点的值
  304.  
  305. * @param mixed $key 顺序表新结点的下标
  306.  
  307. * @param bool $tag 是否指定新结点的下标,1表示默认下标,2表示指定下标
  308.  
  309. * @return bool 插入成功返回true，失败返回false
  310.  
  311. * */
  312.  
  313. public function getInsertElement($p,$value,$key=null,$tag=1){
  314.  
  315. $p=(int)$p;
  316.  
  317. $len=count($this->oll);
  318.  
  319. $oll=array();
  320.  
  321. $i=0;
  322.  
  323. if($p > $len || $p < 1){
  324.  
  325. return false;
  326.  
  327. }
  328.  
  329. foreach($this->oll as $k=>$v){
  330.  
  331. $i++;
  332.  
  333. if($i==(int)$p){
  334.  
  335. if($tag == 1){
  336.  
  337. $oll[]=$value;
  338.  
  339. }else if($tag == 2){
  340.  
  341. $keys=array_keys($oll);
  342.  
  343. $j=0;
  344.  
  345. if(is_int($key)){
  346.  
  347. while(in_array($key,$keys,true)){
  348.  
  349. $key++;
  350.  
  351. }
  352.  
  353. }else{
  354.  
  355. while(in_array($key,$keys,true)){
  356.  
  357. $j++;
  358.  
  359. $key.=(string)$j;
  360.  
  361. }
  362.  
  363. }
  364.  
  365. $oll[$key]=$value;
  366.  
  367. }else{
  368.  
  369. return false;
  370.  
  371. }
  372.  
  373. $key=$k;
  374.  
  375. $j=0;
  376.  
  377. $keys=array_keys($oll);
  378.  
  379. if(is_int($key)){
  380.  
  381. $oll[]=$v;
  382.  
  383. }else{
  384.  
  385. while(in_array($key,$keys,true)){
  386.  
  387. $j++;
  388.  
  389. $key.=(string)$j;
  390.  
  391. }
  392.  
  393. $oll[$key]=$v;
  394.  
  395. }
  396.  
  397. }else{
  398.  
  399. if($i>$p){
  400.  
  401. $key=$k;
  402.  
  403. $j=0;
  404.  
  405. $keys=array_keys($oll);
  406.  
  407. if(is_int($key)){
  408.  
  409. $oll[]=$v;
  410.  
  411. }else{
  412.  
  413. while(in_array($key,$keys,true)){
  414.  
  415. $j++;
  416.  
  417. $key.=(string)$j;
  418.  
  419. }
  420.  
  421. $oll[$key]=$v;
  422.  
  423. }
  424.  
  425. }else{
  426.  
  427. if(is_int($k)){
  428.  
  429. $oll[]=$v;
  430.  
  431. }else{
  432.  
  433. $oll[$k]=$v;
  434.  
  435. }
  436.  
  437. }
  438.  
  439. }
  440.  
  441. }
  442.  
  443. $this->oll=$oll;
  444.  
  445. return true;
  446.  
  447. }
  448.  
  449. /**
  450.  
  451. * 根据元素位置返回顺序表中的某个元素
  452.  
  453. *
  454.  
  455. * @param int $position 元素位置从1开始
  456.  
  457. * @return array array('value'=>...)元素值，array('key'=>...)元素下标 */
  458.  
  459. public function getElemForPos($position){
  460.  
  461. $i=0;
  462.  
  463. $len=count($this->oll);
  464.  
  465. $position=(int)$position;
  466.  
  467. if($position > $len || $position < 1){
  468.  
  469. return false;
  470.  
  471. }
  472.  
  473. foreach($this->oll as $val){
  474.  
  475. $i++;
  476.  
  477. if($i == $position){
  478.  
  479. return array('value'=>current($this->oll),'key'=>key($this->oll));
  480.  
  481. }
  482.  
  483. }
  484.  
  485. }
  486.  
  487. /**
  488.  
  489. * 根据下标或者元素值删除顺序表中的某个元素
  490.  
  491. *
  492.  
  493. * @param mixed $value 元素下标或者值
  494.  
  495. * @param int $tag 1表示$value为下标，2表示$value为元素值
  496.  
  497. * @return bool 成功返回true,失败返回false
  498.  
  499. * */
  500.  
  501. public function getDeleteElement($value,$tag=1){
  502.  
  503. $len=count($this->oll);
  504.  
  505. foreach($this->oll as $k=>$v){
  506.  
  507. if($tag == 1){
  508.  
  509. if(strcmp($k,$value) === 0){
  510.  
  511. }else{
  512.  
  513. if(is_int($k)){
  514.  
  515. $oll[]=$v;
  516.  
  517. }else{
  518.  
  519. $oll[$k]=$v;
  520.  
  521. }
  522.  
  523. }
  524.  
  525. }
  526.  
  527. if($tag ==2){
  528.  
  529. if(strcmp($v,$value) === 0){
  530.  
  531. }else{
  532.  
  533. if(is_int($k)){
  534.  
  535. $oll[]=$v;
  536.  
  537. }else{
  538.  
  539. $oll[$k]=$v;
  540.  
  541. }
  542.  
  543. }
  544.  
  545. }
  546.  
  547. }
  548.  
  549. $this->oll=$oll;
  550.  
  551. if(count($this->oll) == $len){
  552.  
  553. return false;
  554.  
  555. }
  556.  
  557. return true;
  558.  
  559. }
  560.  
  561. /**
  562.  
  563. * 根据元素位置删除顺序表中的某个元素
  564.  
  565. *
  566.  
  567. * @param int $position 元素位置从1开始
  568.  
  569. * @return bool 成功返回true,失败返回false
  570.  
  571. * */
  572.  
  573. public function getDeleteEleForPos($position){
  574.  
  575. $len=count($this->oll);
  576.  
  577. $i=0;
  578.  
  579. $position=(int)$position;
  580.  
  581. if($position > $len || $position < 1){
  582.  
  583. return false;
  584.  
  585. }
  586.  
  587. foreach($this->oll as $k=>$v){
  588.  
  589. $i++;
  590.  
  591. if($i == $position){
  592.  
  593. }else{
  594.  
  595. if(is_int($k)){
  596.  
  597. $oll[]=$v;
  598.  
  599. }else{
  600.  
  601. $oll[$k]=$v;
  602.  
  603. }
  604.  
  605. }
  606.  
  607. }
  608.  
  609. $this->oll=$oll;
  610.  
  611. if(count($this->oll) == $len){
  612.  
  613. return false;
  614.  
  615. }
  616.  
  617. return true;
  618.  
  619. }
  620.  
  621. }
  622.  
  623. ?>
  624.  
  625. $oll=new OrderLinearList(array('xu'=>'徐典阳',32,"是吧",'dianyang'=>10,455));
  626.  
  627. //判断顺序表是否为空,返回false说明不为空
  628.  
  629. var_dump($oll->isEmpty());
  630.  
  631. echo "<br />";
  632.  
  633. //返回顺序表的长度 返回6
  634.  
  635. echo $oll->getLength();
  636.  
  637. echo "<br />";
  638.  
  639. //根据下标返回顺序表中的某个元素
  640.  
  641. var_dump($oll->getElement(1));
  642.  
  643. echo "<br/>";
  644.  
  645. //返回顺序表中某个元素的位置
  646.  
  647. echo $oll->getElementPosition("是吧");
  648.  
  649. echo "<br/>";
  650.  
  651. //返回顺序表中某个元素的直接前驱元素
  652.  
  653. var_
  654.  
  655. dump($oll->getElementPredecessorr("是吧",2));
  656.  
  657. echo "<br />";
  658.  
  659. //返回顺序表中某个元素的直接后继元素
  660.  
  661. var_dump($oll->getElementSubsequence("是吧",2));
  662.  
  663. echo "<br />";
  664.  
  665. //根据元素位置返回顺序表中的某个元素
  666.  
  667. var_dump($oll->getElemForPos(2));
  668.  
  669. echo "<br />";
  670.  
  671. //根据下标或者元素值删除顺序表中的某个元素
  672.  
  673. var_dump($oll->getDeleteElement('徐典阳',$tag=2));
  674.  
  675. echo "<br />";
  676.  
  677. //根据元素位置删除顺序表中的某个元素
  678.  
  679. var_dump($oll->getDeleteEleForPos(1));
  680.  
  681. echo "<br/>";
  682.  
  683. $oll->getInsertElement(3,"徐珍",$key="xuzheng",$tag=2);
  684.  
  685. var_dump($oll->oll);
  686.  
  687. echo "<br />";
  688.  
  689. ?>

PHP数据结构之二 线性表中的顺序表的PHP实现的更多相关文章

  1. c++实现线性表中的顺序表（数据结构课程作业）

    一.题目简介 实现顺序表的创建.初始化.赋值.插入.删除.按数据查找元素位置.按元素位置查找数据.清空.删除 的操作,以上操作用可用菜单选项完成 二.源程序代码 #include<iostrea ...

  2. 老郭带你学数据结构（C语言系列）1-线性表之静态顺序表

    在学习之前,先说下我的软件情况,操作系统是manjaro linux 今天刚刚升级的,编辑器是vim8.0.55,编译器是gcc 6.2.1,调试器是gdb 7.12,版本再低点也可以,只要gcc版本 ...

  3. 老郭带你学数据结构（C语言系列）2-线性表之动态顺序表

    一.基本概念: 线性表:由n个类型相同的数据元素组成的有限序列,记为(a1,a2,--an). 线性表的特征:其中的元素存在这序偶关系,元素之间存在着严格的次序关系. 顺序存储表:线性表中的元素依次存 ...

  4. 关于数据库优化1——关于count(1)，count(*),和count(列名)的区别，和关于表中字段顺序的问题

    1.关于count(1),count(*),和count(列名)的区别 相信大家总是在工作中,或者是学习中对于count()的到底怎么用更快.一直有很大的疑问,有的人说count(*)更快,也有的人说 ...

  5. B表中的pid对应A表中id，查询A表中数据，根据b表中对应a表中该id的数据数目排序

    B表中的pid对应A表中id,查询A表中数据,根据b表中对应a表中该id的数据数目排序 select a.*,count(*) as c from a left join b on a.id=b.ai ...

  6. java 中的JDK封装的数据结构和算法解析（集合类）----顺序表 List 之 ArrayList

    1. 数据结构之List (java:接口)[由于是分析原理,这里多用截图说明] List是集合类中的容器之一,其定义如下:(无序可重复) An ordered collection (also kn ...

  7. （十二）Hibernate中的多表操作（2）：单向多对一

    由“多”方可知“一”方的信息,比如多个员工使用同一栋公寓,员工可以知道公寓的信息,而公寓无法知道员工的信息. 案例一:使用xml配置 pojo类 Group.java package bean; // ...

  8. 【线性表基础】顺序表和单链表的插入、删除等基本操作【Java版】

    本文表述了线性表及其基本操作的代码[Java实现] 参考书籍 :<数据结构 --Java语言描述>/刘小晶 ,杜选主编 线性表需要的基本功能有:动态地增长或收缩:对线性表的任何数据元素进行 ...

  9. c语言数据结构，你可能还不知道的顺序表

    数据结构顺序表 顺序表定义 1,前言 线性表的顺序存储又称为顺序表.它是用一组地址连续的存储单元依次存储线性表中的数据元素,从而使得逻辑上相邻的两个元素在物理位置上也相邻.其最大的特点就是:元素的逻辑 ...

随机推荐

  1. zoj-3963 Heap Partition(贪心+二分+树状数组)

    题目链接: Heap Partition Time Limit: 2 Seconds      Memory Limit: 65536 KB      Special Judge A sequence ...

  2. 在Blender上安装RenderMan插件

    2018/3/27 Download and Install Blender itself Download RenderMan Installer (Need to register an acco ...

  3. I/O多路复用方案

    1. 本节思维导图 2. 基本的网络编程接口 2.1 基于TCP的通信模型 2.2 基于UDP的通信模型 3. 非阻塞的服务器程序 file.pipe.fifo.socket在默认创建过程中都是阻塞的 ...

  4. 安卓开发第一记 android stdio 安装后 新建测试项目报错

    Failed to resolve:com.android.support:appcompat-v7:报错处理   你在使用android studio时是否也出现过上图的报错,你还在为它的出现烦恼? ...

  5. 51nod 2006 飞行员配对

    第二次世界大战时期,英国皇家空军从沦陷国征募了大量外籍飞行员.由皇家空军派出的每一架飞机都需要配备在航行技能和语言上能互相配合的2名飞行员,其中1名是英国飞行员,另1名是外籍飞行员.在众多的飞行员中, ...

  6. 解决安装Weblogic domain卡住问题（Primeton BPS）

    这两天一直有一个问题困扰我,在suse10+weblogic(920,923,100,103)上安装bpm产品失败.有些版本是创建domain的时候卡在create security informat ...

  7. nginx 限制

    在nginx.conf里的http{}里添加: http{ limit_conn_zone $binary_remote_addr zone=perip:10m; limit_conn_zone $s ...

  8. Zombie进程

    fork()的作用就是创建一个该进程下的子进程,在其exit 或 exec之前,和他共享代码,以一个父进程的身份,完成以下工作: 1.分配标识符pid和PCB. 2.让子进程复制父进程的环境. 3.给 ...

  9. CAN总线标准帧

    CAN总线是一种串行数据通信协议,其通信接口中集成了CAN协议的物理层和数据链路层功能,可完成对通信数据的成帧处理,包括位填充.数据块编码.循环冗余检验.优先级判别等项工作. CAN总线结构 CAN总 ...

  10. module_param 用于动态开启/关闭 驱动打印信息

    1.定义模块参数的方法: module_param(name, type, perm); 其中,name:表示参数的名字;      type:表示参数的类型;      perm:表示参数的访问权限 ...