zoukankan      html  css  js  c++  java
  • JS实现单链表、单循环链表

    链表

      链表是一种物理存储单元上非线性、非连续性的数据结构(它在数据逻辑上是线性的),它的每个节点由两个域组成:数据域和指针域。数据域中存储实际数据,指针域则存储着指针信息,指向链表中的下一个元素或者上一个元素。正是由于指针的存在,链表的存储在物理单元是非连续性的。 

            链表的优点和缺点同样明显。和线性表相比,链表在添加和删除节点上的效率更高,因为其只需要修改指针信息即可完成操作,而不像线性表(数组)那样需要移动元素。同样的,链表的长度在理论上也是无限的(在存储器容量范围内),并可以动态变化长度,相比线性表优势很大。 相应的,由于线性表无法随机访问节点,只能通过指针顺着链表进行遍历查询来访问,故其访问数据元素的效率比较低。  

     

    JS实现单链表

    function LinkedList() {
        let Node = function (ele) {
            this.ele = ele;
            this.next = null;
        }
    
        let length = 0,
            head = null; //头指针
    
        //向尾部追加元素
        this.append = function (ele) {
            let node = new Node(ele),
                temp; //临时指针
    
            if (!head) {
                head = node;
            } else {
                temp = head;
                while (temp.next) {
                    temp = temp.next
                }
                temp.next = node;
            }
            length++;
            return true;
        }
    
        //插入到指定位置
        this.insert = function (position, ele) {
            if (position >= 0 && position < length) {
                let node = new Node(ele),
                    temp = head,
                    index = 0,
                    previous;
    
                if (position == 0) {
                    node.next = temp;
                    head = node;
                } else {
                    while (index++ < position) {
                        previous = temp;
                        temp = temp.next;
                    }
                    node.next = temp;
                    previous.next = node;
                }
                length++;
                return true;
            } else {
                return false;
            }
        }
    
        //删除指定位置元素
        this.removeAt = function (position) {
            if (position > -1 && position < length) {
                let temp = head,
                    previous,
                    index = 0;
    
                if (position == 0) {
                    head = head.next;
                } else {
                    while (index++ < position) {
                        previous = temp;
                        temp = temp.next;
                    }
    
                    previous.next = temp.next;
                }
                length--;
                return temp.ele;
            } else {
                return null;
            }
        }
    
        //删除所有值为ele的元素
        this.removeEle = function (ele) {
            let temp = head,
                previous,
                num = 0;
            if (ele == temp.ele) {
                head = head.next;
                length--;
                num++;
            }
    
            while (temp.next) {
                previous = temp;
                temp = temp.next;
                if (temp.ele == ele) {
                    previous.next = temp.next;
                    length--;
                    num++;
                }
            }
            return num;
        }
    
        //删除最后一个元素
        this.pop = function () {
            let temp = head,
                previous = temp;
            if (length < 1) {
                return false;
            }
            if (length == 1) {
                head = null;
                length--;
                return temp.ele;
            }
            while (temp.next) {
                previous = temp;
                temp = temp.next;
            }
            previous.next = null;
            length--;
            return temp.ele;
        }
    
        this.indexOf = function (ele) {
            let temp = head,
                index = 0;
    
            while (temp) {
                if (temp.ele == ele) {
                    return index;
                }
                temp = temp.next;
                index++;
            }
            return -1;
    
        }
    
        this.toString = function () {
            let temp = head,
                string = '';
    
            while (temp) {
                string += temp.ele + ' ';
                temp = temp.next;
    
            }
            return string;
        }
        this.length = function () {
            return length;
        }
        this.isEmpty = function () {
            return length === 0;
        };
        this.getHead = function () {
            return head.ele;
        }
    }
    
    let mylist = new LinkedList();
    mylist.append('A');
    mylist.append('B');
    mylist.append('C');
    mylist.append('D');
    mylist.append('C');
    mylist.append('B');
    mylist.append('A');
    console.log(mylist.toString());
    console.log(mylist.pop());
    console.log(mylist.toString());
    console.log('移除%d个C', mylist.removeEle('C'));
    console.log(mylist.toString());
    console.log(mylist.length());
    console.log(mylist.getHead());
    
    console.log(mylist.indexOf('C'))

     JS实现单循环链表:

    在单链表的基础上,将尾节点的指针指向头结点,就构成了一个循环链表。环形链表从任意一个节点开始,都可以遍历整个链表。

    function CircularLinkedList(){  
        var Node = function(element){  
            this.element = element;  
            this.next = null;  
        }  
      
        var length = 0,  
            head   = null;  
      
        this.append = function(element){  
            var node = new Node(element),  
                current;  
      
            if (!head) {  
                head = node;  
                node.next = head;  
            }else{  
                current = head;  
      
                while(current.next !== head){  
                    current = current.next;  
                }  
      
                current.next = node;  
                node.next = head;  
            };  
      
            length++;  
            return true;  
        };  
      
        this.insert = function(position, element){  
            if(position > -1 && position < length){  
                var node = new Node(element),  
                    index = 0,  
                    current = head,  
                    previous;  
      
      
                if (position === 0) {  
      
                    node.next = head;  
                    head = node;  
      
                }else{  
      
                    while(index++ < position){  
                        previous = current;  
                        current = current.next;  
                    }  
      
                    previous.next = node;  
                    node.next = current;  
      
                };  
      
                length++;  
                return true;  
            }else{  
                return false;  
            }  
        };  
      //移除指定位置元素
        this.removeAt = function(position){  
            if(position > -1 && position < length){  
                var current = head,  
                    previous,  
                    index = 0;  
      
                if (position === 0) {  
      
                    head = current.next;  
      
                }else{  
      
                    while (index++ < position){  
                        previous = current;  
                        current = current.next;  
                    }  
      
                    previous.next = current.next;  
                };  
      
                length--;  
                return current.element;  
            }else{  
                return null;  
            }  
        };  
      //移除指定元素
        this.remove = function (element){  
            var current = head,  
                previous,  
                indexCheck = 0;  
      
            while(current && indexCheck < length){  
                if(current.element === element){  
                    if(indexCheck == 0){  
                        head = current.next;  
                        length--;  
                        return true;  
                    }else{  
                        previous.next = current.next;  
                        length--;  
                        return true;  
                    }  
                }else{  
                    previous = current;  
                    current = current.next;  
                    indexCheck++;  
                }  
            }  
            return false;  
        };  
      //移除最后一个元素
        this.remove = function(){  
            if(length === 0){  
                return false;  
            }  
      
            var current = head,  
                previous,  
                indexCheck = 0;  
      
            if(length === 1){  
                head = null;  
                length--;  
                return current.element;  
            }  
      
            while(indexCheck++ < length){  
                previous = current;  
                current = current.next;  
            }  
            previous.next = head;  
            length--;  
            return previous.element;  //返回移除的元素
        };  
      
        this.indexOf = function(element){  
            var current = head,  
                index = 0;  
      
            while(current && index < length){  
                if(current.element === element){  
                    return index;  
                }else{  
                    index++;  
                    current = current.next;  
                }  
            }  
            return false;  
        };  
      
      
        this.isEmpty = function(){  
            return length === 0;  
        };  
      
        this.size = function(){  
            return length;  
        };  
      
        this.toString = function(){  
            var current = head,  
                string = '',  
                indexCheck = 0;  
      
            while(current && indexCheck < length){  
                string += current.element;  
                current = current.next;  
                indexCheck++;  
            }  
      
            return string;  
        };     
    
    }  

    let mylist=new CircularLinkedList();
    mylist.append('A');
    mylist.append('B');
    mylist.append('C');
    mylist.append('D');

    console.log(mylist.toString());
    console.log(mylist.remove()); //D
    console.log(mylist.toString());
     
  • 相关阅读:
    Educational Codeforces Round 20 D. Magazine Ad
    Educational Codeforces Round 20 C. Maximal GCD
    紫书第三章训练2 暴力集
    Educational Codeforces Round 20 B. Distances to Zero
    Educational Codeforces Round 20 A. Maximal Binary Matrix
    紫书第三章训练1 D
    紫书第一章训练1 D -Message Decoding
    HAZU校赛 Problem K: Deadline
    Mutual Training for Wannafly Union #8 D
    紫书第三章训练1 E
  • 原文地址:https://www.cnblogs.com/xbblogs/p/9897118.html
Copyright © 2011-2022 走看看