JavaScriptで機能完備のシングルチェーンテーブルを実現

前言
フロントエンドもデータ構造をよくしなければなりませんよ!!
JavaScriptで1つの単一チェーンテーブルを実現し、LinkedList構造関数によって1つの単一チェーンテーブルデータ構造のオブジェクトをインスタンス化することができ、すべての方法はLinkedList構造関数の原型オブジェクトに置かれ、一時的に考えられるすべての方法を書いた.
GitHubソースアドレス、ダウンロード実行可能
インプリメンテーション

LinkedListのクラスを介してチェーンテーブルインスタンスを作成し、チェーンテーブルの下に追加、検索、削除、ノードの表示などの方法

がある.

チェーンテーブルの初期デフォルトには「_head」ヘッダノードがあり、

を非表示にします.

要素/インデックスで追加、削除、見つからない場合はエラー、見つからない場合はnull、または-1

を返します.

let obj = new LinkedList()

方法の紹介
検索

obj.find(item)この要素

はitem要素の内容によって検出される.

obj.findIndex(index) indexインデックスによって要素

が検索される.

obj.findIndexOf(item)この要素インデックス

はitem要素の内容によって検索される.

obj.findPrev(item) item要素で前のノード要素

を検索
追加

obj.insert(item,newElement) itemエレメントの後に新しいエレメント

を挿入する

obj.push(item)チェーンテーブルの末尾にitem要素

を挿入する.

obj.insertIndex(index,newElement) indexインデックスに新しい要素

を挿入する.
削除

obj.remove(item) item要素

を削除

obj.removeIndex(index) indexインデックスのノード

を削除する.
その他

obj.size()は、チェーンテーブルの長さ

を返す.

obj.display()配列形態はこのチェーンテーブルを返し、観察が容易であり、テスト

.

obj.reversal()チェーンテーブル順序反転(再帰)

メソッドコード
チェーンテーブルクラスLinkedList

      function LinkedList (...rest) {
        this._head = new Node('_head') //      
        //   new     ，       
        if (rest.length) {
          this.insert(rest[0], '_head')
          for (let i = 1; i < rest.length; i++) {
            this.insert(rest[i], rest[i - 1])
          }
        }
      }
      LinkedList.prototype.find = find
      LinkedList.prototype.findPrev = findPrev
      LinkedList.prototype.findIndex = findIndex
      LinkedList.prototype.findIndexOf = findIndexOf
      LinkedList.prototype.push = push
      LinkedList.prototype.insert = insert
      LinkedList.prototype.insertIndex = insertIndex
      LinkedList.prototype.remove = remove
      LinkedList.prototype.removeIndex = removeIndex
      LinkedList.prototype.size = size
      LinkedList.prototype.display = display
      LinkedList.prototype.reversal = reversal

新しいノードクラスノードの作成

      function Node (element) {
        this.element = element
        this.next = null
      }

obj.find(item)

//     ，      item   ，     ，     -1
        function find (item) {
          let currNode = this._head
          while (currNode !== null && currNode.element !== item) {
            currNode = currNode.next
          }
          if (currNode !== null) {
            return currNode
          } else {
            return null
          }
        }

obj.findIndex(index)

//             
        function findIndex (index) {
          let currNode = this._head
          let tmpIndex = 0
          while (currNode !== null) {
            //    index  ，      ，     
            if (tmpIndex === index + 1) {
              return currNode
            }
            tmpIndex += 1
            currNode = currNode.next
          }
          return null
        }

obj.findIndexOf(item)

        function findIndexOf (item) {
          let currNode = this._head
          let tmpIndex = 0
          while (currNode.next !== null && currNode.next.element !== item) {
            tmpIndex += 1
            currNode = currNode.next
          }
          if (currNode !== null) {
            return tmpIndex
          } else {
            return -1
          }
        }

obj.findPrev(item)

//       item      ，     -1
        function findPrev (item) {
          let currNode = this._head
          while (currNode.next !== null && currNode.next.element !== item) {
            currNode = currNode.next
          }
          if (currNode.next !== item) {
            return currNode
          } else {
            return null
          }
        }

obj.insert(item,newElement)

//     ，       item     ，      item  
        function insert (newElement, item) {
          let newNode = new Node(newElement)
          let currNode = this.find(item)
          if (currNode) {
            newNode.next = currNode.next
            currNode.next = newNode
          } else {
            console.error(`insert error：      「${item}」  `)
          }
        }

obj.insertIndex(index,newElement)

//     ，     index   
        function insertIndex (newElement, index) {
          let newNode = new Node(newElement)
          let currNode = this.findIndex(index)
          if (currNode) {
            newNode.next = currNode.next
            currNode.next = newNode
          } else {
            console.error(`insertIndex error：      「${index}」    `)
          }
        }

obj.push(item)

//            
        function push (element) {
          let newNode = new Node(element)
          let currNode = this._head
          while (currNode.next !== null) {
            currNode = currNode.next
          }
          currNode.next = newNode
        }

obj.remove(item)

//     ，       ，  ，       
        function remove (item) {
          //           ，       next  item     
          let tmpPrev = this.findPrev(item)
          let tmpNext = this.find(item)
          if (tmpPrev && tmpNext) {
            tmpPrev.next = tmpNext.next
          } else {
            console.error(`remove error：      「${item}」  `)
          }
        }

obj.removeIndex(index)

//           
        function removeIndex (index) {
          let tmpPrev = this.findIndex(index - 1)
          let currNode = this.findIndex(index)
          if (tmpPrev && currNode) {
            tmpPrev.next = currNode.next
          } else {
            console.error(`removeIndex error：      「${index}」    `)
          }
        }

obj.size()

        function size () {
          let currNode = this._head
          let tmpSize = 0
          while (currNode.next !== null) {
            tmpSize += 1
            currNode = currNode.next
          }
          return tmpSize //        
        }

obj.reversal()

      //     =>  
      function reversal () {
        function reversalList (item) {
          if (item.next) {
            let tmpItem = reversalList(item.next)
            item.next = null
            tmpItem.next = item
            return item
          } else {
            obj._head.next = item
            return item
          }
        }
        reversalList(obj._head.next)
      }

obj.display()

        function display () {
          //        ，       
          let currNode = this._head.next
          let tmpArr = []
          while (currNode !== null) {
            tmpArr.push(currNode)
            currNode = currNode.next
          }
          return tmpArr
        }

インスタンステスト

      //     
      let obj = new LinkedList('  0', '  1', '  2', '  3', '  4', '  5')
      console.log('---    ')
      console.log(obj)
      console.log('---      ')
      obj.push('push  ')
      console.log(obj.display())
      console.log('---       ')
      obj.insert('    ', '  2')
      console.log(obj.display())
      console.log('---       ')
      obj.insertIndex('    ', 5)
      console.log(obj.display())
      console.log('---      ')
      console.log(obj.find('  4'))
      console.log('---    ')
      obj.remove('  5')
      console.log(obj.display())
      console.log('---      ')
      obj.removeIndex(5)
      console.log(obj.display())
      console.log('---    ')
      console.log(obj.size())
      console.log('---    ')
      console.log(obj.findIndex(2))
      console.log('---      ')
      console.log(obj.findIndexOf('  3'))
      console.log('---    ')
      obj.reversal()
      console.log(obj.display())

テスト結果
の最後の部分
最近、単一チェーンテーブルの反転の問題に遭遇し、すべての単一チェーンテーブルの反転を追加する方法を再帰的に実現しました.
関連リンク
単一チェーンテーブルの反転を実現するいくつかの方法JavaScriptで機能的な単一チェーンテーブルを実現する方法