链表算法题

Posted 2022-11-01 huahongcui

单链表

 function LinkedList() 
        //需要插入链表的元素
        var Node = function(element) 
            this.element = element;//元素的值
            this.next = null;//指向下一个节点项的指针
        ;

        var length = 0;//链表的长度
        var head = null;//链表中第一个节点(的引用)

        //向链表尾部追加元素
        this.append = function(element) 

            var node = new Node(element), current;

            if(head === null) 
                //当链表为空时
                head = node;
             else 
                //要从第一个元素找起
                current = head;

                //循环链表，直到找到最后一项
                while(current.next) 
                    current = current.next;
                

                //把元素插入到链表的末尾
                current.next = node;
            

            length++;
        ;

        //从链表中根据位置移除元素并返回该元素
        this.removeAt = function(position) 
            if (position > -1 && position < length) 
                var current = head,
                    previous,
                    index = 0;

                //移除第一项
                if(position == 0) 
                    head = current.next;
                    return current.element;
                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 index = this.indexOf(element);
            return this.removeAt(index);
        ;

        //在任意位置插入一个元素
        this.insert = function(position, element) 
            if(position > -1 && position <= length) 
                var node = new Node(element),
                    current = head,
                    previous,
                    index = 0;

                if(position === 0) //在第一个位置添加
                    node.next = current;
                    head = node;
                else
                    while(index++ < position) 
                        previous = current;
                        current = current.next;
                    
                    node.next = current;
                    previous.next = node;
                
                length++;
                return true;
            else
                return false;
            
        ;

        //找到并返回一个元素的位置，如果元素不存在，返回-1
        this.indexOf = function(element) 
            var current = head,
                index = 0;

            while(current) 
                if(element === current.element) 
                    return index;
                
                index++;
                current = current.next;
            

            return -1;
        ;

        //判断链表是否为空
        this.isEmpty = function() 
            return length === 0;
        ;

        //返回链表的长度
        this.size = function() 
            return length;
        ;

        //查看链表中元素的值(转换为字符串)
        this.toString = function() 
            var current = head,
                string = ‘‘;

            while(current) 
                string += "," + current.element;
                current = current.next;
            
            return string.slice(1);
        ;

        //返回链表中第一个元素
        this.getHead = function() 
            return head;
        ;

        //查看链表(中的元素和指针，以数组形式输出)
        this.print = function() 
            var current = head,
                list = [];

            while(current) 
                list.push(current);
                current = current.next;
            
            return list;
        ;
    

    var list = new LinkedList();
    list.append(5);
    console.log(list.toString());
    console.log(list.print());
    console.log(list.indexOf(115));
    console.log(list.isEmpty());
    console.log(list.size());
    console.log(list.getHead());

    console.log(list.removeAt(0));
    console.log(list.toString());
    console.log(list.removeAt(1));
    console.log(list.toString());

    list.insert(0, 500);
    console.log(list.toString());

删除链表中重复的结点

//思路

特殊情况：单链表，空链表
新建一个节点newHead，放在头节点前面，当头节点需要被删除时，方便返回结果
pre指针指向前一个节点（初始为newHead）cur指向当前节点（初始为头节点），next指向下一个节点（初始为null）
cur不空，cur.next不空时，进入循环，依次比较节点，next保存cur.next
如果cur和next值相等，就进入循环，依次向后查找所有重复元素，然后删除中间所有重复元素（pre.next = next;），cur指向next的当前位置
如果cur和next值不相等，pre和cur依次向后移动，继续比较
最后遍历结束，退出循环，返回头节点：newHead.next

function deleteDuplication(pHead) 
  if (!pHead || !pHead.next) return pHead;
  let newHead = new ListNode("head"); //新建一个节点
  newHead.next = pHead; //充当新的头节点，当head节点被删除时可以返回正确的头节点
  let pre = newHead; //pre指向前一个节点
  let cur = pHead; //cur指向当前节点
  let next = null; //next指向下一个节点
  while (cur && cur.next) 
    //当前节点不空且下一个节点不空时，进入比较循环
    next = cur.next; //next存放下个节点的位置
    if (next.val === cur.val) 
      //cur和next值相等
      //进入循环向后查找所有重复元素
      while (next && next.val === cur.val) 
        next = next.next; //next后移一位
      
      //next空或者next和cur值不相等，退出循环
      pre.next = next; //删除中间重复的节点
      cur = next; //cur指针指向next的位置
     else 
      //cur和next值不相等
      pre = cur; //pre和cur都后移
      cur = next;
    
  
  return newHead.next;

回文链表

 

var isPalindrome = function(head, queue = []) 
  if (!head) 
    return true;
  
  queue.push(head.val);
  let flag = isPalindrome(head.next, queue);
  return queue.shift() === head.val && flag;

查找单链表中间节点

<!--查找单链表的中间结点：
定义两个节点k1、k2，k1一次走两步，k2一次走一步，
当k2走到尽头时此时k1所在的位置中间节点。-->

<!--输入：[1,2,3,4,5,6]
输出：此列表中的结点 4 (序列化形式：[4,5,6])
由于该列表有两个中间结点，值分别为 3 和 4，我们返回第二个结点。

-->

    /**
     * Definition for singly-linked list.
     * function ListNode(val) 
     *     this.val = val;
     *     this.next = null;
     * 
     */
  
    var middleNode = function(head) 
        var length = 1,
            node = head;
        //测量链表长度
        while(node.next !== null)
            length++;
            node = node.next;
        
        //设置中间长度
        if(length % 2 === 0)
            length = length / 2 + 1;
        else
            length = Math.ceil(length / 2);
        
        //重新查找中间长度的节点
        node = head;
        while(length !== 1)
            node = node.next;
            length--;
        

        return node;
    ;

 

查找单链表倒数第K个节点

//思路
简单思路： 循环到链表末尾找到 length 在找到length-k节点 需要循环两次。

//优化：

设定两个节点，间距相差k个节点，当前面的节点到达终点，取后面的节点。

前面的节点到达k后，后面的节点才出发。

//代码鲁棒性： 需要考虑head为null，k为0，k大于链表长度的情况。


function FindKthToTail(head, k) 
      if (!head || !k) return null;
      let front = head;
      let behind = head;
      let index = 1;
      while (front.next) 
        index++;
        front = front.next;
        if (index > k) 
          behind = behind.next;
        
      
      return (k <= index) && behind;
    

 

单链表反转

//以链表的头部节点为基准节点

//将基准节点的下一个节点挪到头部作为头节点

//当基准节点的next为null，则其已经成为最后一个节点，链表已经反转完成

 var reverseList = function (head) 
      let currentNode = null;
      let headNode = head;
      while (head && head.next) 
        currentNode = head.next;
        head.next = currentNode.next;
        currentNode.next = headNode;
        headNode = currentNode;
      
      return headNode;
    ;

 数组转链表

function array2list(ary) 
    if(!ary.length) 
        return null
    

    var node
    var head = value: ary[0], next: null
    var pnode = head  //pnode变量用来保存前一个节点

    for(var i = 1; i < ary.length; i++) 
        node = value: ary[i], next:null
        pnode.next = node   //将前一个节点的next指向当前节点
        pnode = node   //将node赋值给pnode
    

    return head

 

链表转数组

function list2array(head) 
    if(!head) 
        return []
    
    var result = [head.value]
    var restValues = list2array(head.next)
    return result.concat(restValues)

奇偶链表

//题目：给定单链表，将所有奇数节点组合在一起，然后是偶数节点。
//思路

特殊情况，空/单/双链表不需要修改顺序
odd指向奇数节点，even指向偶数节点，evenHead保存第一个偶节点
while循环控制后移，条件：even && odd && even.next，因为even.next需要even存在，所以要先判断even，
因为odd.next夹在了中间，所以只需要判断最后的额 even.next存在
odd在even前，所以先移动odd——先改变.next指针，再将odd/even指向.next的位置。
最后连接奇偶链表，返回头节点head

var oddEvenList = function(head) 
  if (!head || !head.next || !head.next.next) 
    return head;
  
  let odd = head, //odd指向奇数节点
    evenHead= head.next,
    even = head.next; //even指向偶数节点，evenHead保存第一个偶节点
  while (even && odd && even.next) 
    odd.next = even.next; //奇节点指向奇节点
    odd = odd.next; //odd指针移向下一个奇节点
    even.next = odd.next; //偶节点指向偶节点
    even = even.next; //even指针移向下一个奇节点
  
  odd.next = evenHead; //连接奇偶链表
  return head;
; 

合并两个单链表

//思路：

对两个链表，各自设置一个游标节点指向头节点，对游标节点上的数值进行比较，


小节点的next等于小节点的next和大节点的较小值。数值小的那个拿出来放入到合并链表中，

如此递归。

返回小节点。

//考虑代码的鲁棒性，也是递归的终止条件，两个head为null的情况，取对方节点返回。
function Merge(pHead1, pHead2) 
      if (!pHead1) 
        return pHead2;
      
      if (!pHead2) 
        return pHead1;
      
      let head;
      if (pHead1.val < pHead2.val) 
        head = pHead1;
        head.next = Merge(pHead1.next, pHead2);
       else 
        head = pHead2;
        head.next = Merge(pHead1, pHead2.next);
      
      return head;
    

 

两个链表的第一个公共节点

//思路
1.先找到两个链表的长度length1、length2

2.让长一点的链表先走length2-length1步，让长链表和短链表起点相同

3.两个链表一起前进，比较获得第一个相等的节点

时间复杂度O(length1+length2) 空间复杂度O(0)

function FindFirstCommonNode(pHead1, pHead2) 
      if (!pHead1 || !pHead2)  return null; 
      // 获取链表长度
      let length1 = getLength(pHead1);
      let length2 = getLength(pHead2);
      // 长链表先行
      let lang, short, interval;
      if (length1 > length2) 
        lang = pHead1;
        short = pHead2;
        interval = length1 - length2;
       else 
        lang = pHead2;
        short = pHead1;
        interval = length2 - length1;
      
      while (interval--) 
        lang = lang.next;
      
      // 找相同节点
      while (lang) 
        if (lang === short) 
          return lang;
        
        lang = lang.next;
        short = short.next;
      
      return null;
    

    function getLength(head) 
      let current = head;
      let result = 0;
      while (current) 
        result++;
        current = current.next;
      
      return result;
    

 

双向链表

// 链表节点
class Node 
    constructor(element) 
        this.element = element
        this.prev = null
        this.next = null
    


// 双向链表
class DoublyLinkedList 

    constructor() 
        this.head = null
        this.tail = null
        this.length = 0
    

    // 任意位置插入元素
    insert(position, element) 
        if (position >= 0 && position <= this.length)
            const node = new Node(element)
            let current = this.head
            let previous = null
            let index = 0
            // 首位
            if (position === 0) 
                if (!head)
                    this.head = node
                    this.tail = node
                 else 
                    node.next = current
                    this.head = node
                    current.prev = node
                
            // 末位
             else if (position === this.length) 
                current = this.tail
                current.next = node
                node.prev = current
                this.tail = node
            // 中位
             else 
                while (index++ < position) 
                    previous = current
                    current = current.next
                
                node.next = current
                previous.next = node
                current.prev = node
                node.prev = previous
            
            this.length++
            return true
        
        return false
    

    // 移除指定位置元素
    removeAt(position) 
        if (position > -1 && position < this.length) 
            let current = this.head
            let previous = null
            let index = 0

            // 首位
            if (position === 0) 
                this.head = this.head.next
                this.head.prev = null
                if (this.length === 1) 
                    this.tail = null
                

            // 末位
             else if (position === this.length - 1) 
                this.tail = this.tail.prev
                this.tail.next = null

            // 中位
             else 
                while (index++ < position) 
                     previous = current
                     current = current.next
                
                previous.next = current.next
                current.next.prev = previous
         
         this.length--
         return current.element
         else 
            return null
        
    

    // 其他方法...