LeetCode算法打卡--链表

最新推荐文章于 2023-01-03 03:25:13 发布
最新推荐文章于 2023-01-03 03:25:13 发布
阅读量217 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qi_700/article/details/98884362
版权

61. 旋转链表

给定一个链表，旋转链表，将链表每个节点向右移动 k 个位置，其中 k 是非负数。

链接：https://leetcode-cn.com/problems/rotate-list/

/**
基本思想：先把单链表改成循环链表，然后头指针一直走loop的长度，最后改成单链表返回头
*/
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
        if(head==NULL || k==0)
            return head;
        ListNode *h = head;   //头指针
        ListNode *f = NULL;   //尾指针
        int length = 1;
        while(h->next!=NULL)
        {
            length++;
            h = h->next;
        }
        int loop = length - (k%length);//循环次数
        f = h;
        h->next = head;
        h = head;
        for(int i=0;i<loop;i++)
        { 
           
            h = h->next;
            f = f->next;
           
        }
        f->next = NULL;  //改成单链表
        return h;
        
    }
};

24. 两两交换链表中的节点

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

链接:https://leetcode-cn.com/problems/swap-nodes-in-pairs/

/*递归思想:按照正常思路交换两个节点为子问题，返回值连接前面的应该正确连接的节点
*/
/*非递归思想：设置三个指针，h指向要交换的第一个节点，f指向要交换的第二个节点，p指向第一个之前的一个节点
    交换的时候：p->next指向f
               h->next指向
               f->nextf->next指向h
              注意循环时，p,h,f的移动（指针是随着交换移动的，不是单纯的值的移动）
*/
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    /*ListNode* swapPairs(ListNode* head) {
        if(head == NULL || head->next == NULL)
            return head;
        ListNode *next = head->next;
        head->next = swapPairs(next->next);
        next->next = head;
        
        return next;
    }*/
    
    ListNode* swapPairs(ListNode* head) {
        
        if(head == NULL || head->next == NULL)
            return head;
        ListNode *p =new ListNode(0);   //设置前面一个虚拟节点
        p->next = head;
        ListNode *h = head;
        ListNode *f = head->next;
        ListNode *newNode = f;
        
        while(h!=NULL)
        {
            p->next = f;
            h->next = f->next;
            f->next = h;
            p = h;
            h = h -> next; 
            if(h==NULL || h->next == NULL)   
                break;
            f = h->next;
        }
        return newNode;
    }
};

 

148. 排序链表

在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。

链接：https://leetcode-cn.com/problems/sort-list/

/*
   基本思想：归并排序，找中点，左右排序合并
            链表的中点用两个指针，一个每次走两步，一个每次走一步，快指针到达最后，则慢指针的位置就是中点
            左右分别归并，注意左边排序时，中点的next要设置为NULL
            左右排序之后合并
*/

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode * getMiddleList(ListNode* L)
    {
        
        ListNode *L1=L;
        ListNode *L2=L->next;
        
        while(L2!=NULL && L2->next != NULL)
        {
            
            L1 = L1->next;
            L2 = L2->next->next;
           
        }
        return L1;
    }
    ListNode* MergeList(ListNode*L1,ListNode* L2)
    {
        if(L1 == NULL)
            return L2;
        if(L2 == NULL)
            return L1;
        ListNode* result = new ListNode(0);
        ListNode* head = result;
        while(L1!=NULL && L2!=NULL){
        if(L1->val <= L2->val)
        {
            result->next = L1;
            L1 = L1->next;
            
        }
        else 
        {
            result->next = L2;
            L2 = L2->next;
        }
            result = result->next;
        }
        if(L1==NULL)
        {
             result->next = L2;
        }
        if(L2==NULL)
            result->next = L1;
        return head->next;
    }
    ListNode *sortList(ListNode *head) {
        if(head==NULL || head->next == NULL)
            return head;
        
        ListNode *middle = getMiddleList(head); 
        cout<<middle->val<<endl;
        ListNode *right = sortList(middle->next);
        
        middle->next = NULL; 
        ListNode *left = sortList(head);
        
        return MergeList(left,right);
    }
};

92. 反转链表 II

反转从位置 m 到 n 的链表。请使用一趟扫描完成反转。

说明:
1 ≤ m ≤ n ≤ 链表长度。

链接：https://leetcode-cn.com/problems/reverse-linked-list-ii/

/*
   基本思想：把要反转的部分截取出来，进行反转，然后再拼接
    注意，对于链表操作的时候，指向的链表的指针对链表的修改就是整个链表的变动
*/
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        ListNode *ltail;
        ListNode *rhead;
        ListNode *dummyHead = new ListNode(0);
        ListNode *cur = dummyHead;
        ListNode *reversenode;   //保存要反转的部分的头
        dummyHead->next = head;
        int i=0;
        for(i=0;i<=n;i++)
        {
            if(i==m-1)
            {
                ltail = cur;   //前面保留的尾
                reversenode = cur->next;   //要反转的部分的头
            }
           
            if(i==n)
            {
               
                rhead = cur->next;   //后面要保留的部分的头
                cur->next = NULL;    
            }
            
             cur = cur->next;
        }

        ListNode* pre = NULL;
        cur =reversenode;
        while (cur != NULL) {       //进行反转
            ListNode* nextTemp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = nextTemp;
        }
        
           ltail->next = pre;           //连接剩余不变的部分
           reversenode->next = rhead;
        return dummyHead->next;
    }
};

86. 分隔链表

给定一个链表和一个特定值 x，对链表进行分隔，使得所有小于 x 的节点都在大于或等于 x 的节点之前。

你应当保留两个分区中每个节点的初始相对位置。

链接：https://leetcode-cn.com/problems/partition-list/

/*基本思想：先找到第一个大于或等于x的位置，从这个位置开始向后找小于x的，找到就遍历前面的第一个大于或等于x的位置，找到该位置进行链表分开和拼接
*/
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* partition(ListNode* head, int x) {
       ListNode* cur;
        ListNode* dummpNode = new ListNode(0);
        dummpNode->next = head;
        ListNode* lhead = dummpNode;
        ListNode* list =  dummpNode->next;
        int min;
        if(head==NULL)
            return head;
        while(list!=NULL)
        {
            if(list->val >= x )
            {
                 cur = list;
                 break;
            }
               
            list = list->next;
        }

        
        ListNode *pre = cur;
        while(cur!=NULL)
        {
              
            cout<<"c"<<cur->val;
             
            if(cur->val <x){
              
              while(lhead!=NULL&&lhead->next!=NULL)
               {
                   cout<<"l"<<lhead->val;
                if(lhead->next->val >= x)
                {
                    ListNode* tmp = cur;
                    if(tmp!=NULL)
                    {
                      pre->next = cur->next;
                      tmp->next = lhead->next;
                      lhead->next = tmp;
                    }
                    lhead = lhead->next;
                    break;
                    
                } 
                    lhead = lhead->next;
               }
                
            }
        
            pre = cur;
            cur = cur->next;
        
            
        }
        return dummpNode->next;
    }
    
};



//另一种思路：维护两个链表，一个比x大，一个比x小最后两个链表拼接

 

2. 两数相加

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

您可以假设除了数字 0 之外，这两个数都不会以 0 开头


链接：https://leetcode-cn.com/problems/add-two-numbers


 

/*基本思想:就是两个数字对应相加，如果两个链表长度不一样，那短的那个算0来相加。最后都遍历完，考虑最后多出的进位新建一个链表添加在后面
*/

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {
        ListNode *res = new ListNode(0);
        ListNode *r = res;
        ListNode *numlist1 = l1;
        ListNode *numlist2 = l2;
        int num1 ;
        int num2 ;
        int rest = 0;
        while(numlist1!=NULL || numlist2!=NULL)
        {
            ListNode *node = new ListNode(0);
            if(numlist1==NULL)
                num1 = 0;
            else
                num1 = numlist1->val;
            if(numlist2==NULL)
                num2 = 0;
            else
                num2 = numlist2->val;
        
            int num = (num1+num2+rest)%10 ;
            rest = (num1+num2+rest)/10;
            node->val = num;
            res->next = node;
            res = node;
            if(numlist1==NULL)
                numlist1=NULL;
            else
                numlist1 = numlist1->next;
            if(numlist2==NULL)
                numlist2=NULL;
            else                
                numlist2 = numlist2->next;
        }
        if(rest!=0)
        {
            ListNode *node = new ListNode(rest);
            res->next = node;
        }
        return r->next;
    }
};

143. 重排链表

给定一个单链表 L：L0→L1→…→Ln-1→Ln ，
将其重新排列后变为： L0→Ln→L1→Ln-1→L2→Ln-2→…

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。


链接：https://leetcode-cn.com/problems/reorder-list

/*基本思想：分三步，先利用快慢指针找到中点，然后分成左部分和右部分，对右部分反转，然后两个部分合并
*/
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    void reorderList(ListNode* head) {
       
        if(head == NULL)
            return;
        
        //快慢指针找中点
        ListNode *quick = head;
        ListNode *low = head->next;
        
        while(low!=NULL && low->next!=NULL)
        {
            quick = quick->next;
            low = low->next->next;
        }  
        
        //反转右部分
        ListNode *Rhead = quick->next;
        quick->next = NULL;
        ListNode* pre = NULL;
        ListNode *cur = Rhead;
        while (cur != NULL) {
            ListNode* nextTemp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = nextTemp;
        }

        Rhead = pre;

        //合并链表
        ListNode *res = new ListNode(0);
        ListNode *returnh = res;
        int i=1;
       
        while(head!=NULL && Rhead!=NULL)
        { 
         
        
            ListNode*l = head->next;       //记住下一个要找的位置
            ListNode*r = Rhead->next;
           
            if(i%2==0){
                res->next = Rhead;
               Rhead = r;
            }
            else
            {
                res->next = head;
                 head = l;
            }
            res = res->next;

            i++;
        
        }
       
        if(head == NULL)
            res->next = Rhead;
        if(Rhead == NULL)
            res->next = head;
        
        head = returnh->next;
    }
};

19. 删除链表的倒数第N个节点

给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。

链接：https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/

/*基本思想：主要是要找到要删除的节点，三个指针，一个指要删除的节点的之前的节点，快指针先走n步，然后慢指针和快指针同时出发，知道快指针到达末尾，慢指针的位置就是要删除的位置
*/
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        
        
        ListNode* newhead = new ListNode(0);
        newhead->next = head;
        ListNode* l1=newhead;
        ListNode* l2=newhead;
        ListNode* pre=newhead;
        
        while(n>0 && l2!=NULL)
        {
            l2=l2->next;
            n--;
        }
        
        while(l2!=NULL)
        {
            pre = l1;
            l1=l1->next;
            l2=l2->next;
          
        }
        
       
        pre->next = l1->next;
        
        return newhead->next;
    }
};

141. 环形链表

给定一个链表，判断链表中是否有环。

链接：https://leetcode-cn.com/problems/linked-list-cycle/

/*基本思想：利用快慢指针，如果两个指针相遇表示有环，否则没有环
*/

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        
        ListNode* fast=head;
        ListNode* slow=head;
        
        while(fast!=NULL  && fast->next!=NULL)
        {
            fast = fast->next->next;
            slow=slow->next;
            if(fast==slow)
                return true;
        }
        return false;
    }
};

142. 环形链表 II

给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

链接：https://leetcode-cn.com/problems/linked-list-cycle-ii/

基本思想：先利用快慢指针找到第一次相遇的位置，然后一个指针从头开始出发，一个指针从相遇位置开始，再次相遇的点就是环的入口
原理：


X,Y,Z分别为链表起始位置，环开始位置和两指针相遇位置。

由于快指针速度为慢指针速度的两倍，那么这个慢指针最多走圆的一圈（这里想象极端情况，就是整个链表就是一个环，那么两个指针从圆的同一个地方出发，那么此时何时相遇呢？必然是慢指针正好才走一圈的时候，快指针走两圈追上来了）。

所以这里假设就是在Z相遇的，那么慢指针走的距离是a+b，很好计算。而快指针走的距离是2(a+b)，此时我们想象，假设慢指针走到了X和Z的中间的时候，快指针已经到Z了，那么下面再走的话，就是快指针从Z点出发围着圆绕几圈之后恰好在Z点和X相遇，因此快指针走过的距离是：

2(a+b) = a+b+n*圆的周长 = a+b+n(b+c)

此时a为:

a = (n - 1) * b + n * c = (n - 1)(b + c) +c

从公式上看，当一个指针从X出出发，走完a的距离之后，那么另一个指针从相遇点Z出发就会走(n-1)圈的环再加一个C的距离，此时正好在Y点相遇。

因此，一个指针从头出发，一个指针从相遇点出发，速度相同，相遇点就是环的入口节点。
*/
 

/*基本思想：先利用快慢指针找到第一次相遇的位置，然后一个指针从头开始出发，一个指针从相遇位置开始，再次相遇的点就是环的入口

*/

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        
        ListNode *fast=head;
        ListNode *slow=head;
        
        if( fast== NULL || fast->next == NULL)
            return NULL;
        
        while(fast!=NULL && fast->next!=NULL)
        {
            fast = fast->next->next;
            slow = slow->next;
            if(fast == slow)
            {
                break;
            }
        }
         
        while(fast!=NULL && fast!=head )
        {
            fast = fast->next;
            head = head->next;
        }
        
       
        return fast;
    }
};

83. 删除排序链表中的重复元素

给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。

链接：https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list/

/*基本思想：对于每一个链表节点，while循环向后找第一个和他不一样的接到他后面
*/
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        ListNode* p=head;
        while(p!=NULL && p->next!=NULL)
        {
            
            while(p->next!=NULL && p->next->val == p->val)
            {  
                ListNode *next = p->next->next;
                p->next = next;
                
            }
            p =p->next;
            
        }
        return head; 
    }
};

82. 删除排序链表中的重复元素 II

给定一个排序链表，删除所有含有重复数字的节点，只保留原始链表中 没有重复出现 的数字。

链接：https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list-ii/

/*基本思想： 用一个新链表存储只出现一次的链表节点，和之前删除重复元素类似，先找到第一个和他不相等的，不过此时要有一个计数，当总数等于1的时候，才连接，否则不连接，注意最后一个当为空的时候要把新链表最后置为NULL（否则会连接以前存在的）
*/
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        ListNode *newhead = new ListNode(0);
        ListNode *res = newhead;
        ListNode *p = head;
        while(p!=NULL)
        {
            int count = 1;
            while(p->next!=NULL && p->next->val == p->val )
            {
                count++;
                p->next = p->next->next;
            }
            if(count==1)
            {
                cout<<newhead->val<<endl;
                newhead->next = p;
                newhead=newhead->next;
            }
            if(p->next==NULL)
            {
                newhead->next =NULL;
            }
            p=p->next;
        }
    
        return res->next;
    }
};

116. 填充每个节点的下一个右侧节点指针

给定一个完美二叉树，其所有叶子节点都在同一层，每个父节点都有两个子节点。

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。


链接：https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node

 

/*
    基本思路：主要是理解题，对于一个根节点，他的左孩子的next指向右孩子，对于右孩子的next指向根的next的左孩子
             所以只需要对于每一个根节点进行这样的操作就可以，递归处理每一个节点，体中初始的next已经是NULL
*/
/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() {}

    Node(int _val, Node* _left, Node* _right, Node* _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/
class Solution {
public:
    Node* connect(Node* root) {
        
        if(root==NULL)
            return root;
        
        if(root->left!=NULL)
            root->left->next = root->right;
        
        if(root->right!=NULL && root->next)
            root->right->next = root->next->left;
        
        connect(root->left);
        connect(root->right);
        
        return root;
        
        
        
    }
};

117. 填充每个节点的下一个右侧节点指针 II

给定一个二叉树，不是完全二叉树
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。初始状态下，所有 next 指针都被设置为 NULL。


链接：https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node-ii

/*基本思想：和上一个思想一样，也是递归，这个要注意不是完全二叉树的时候，对于next指针可能要找到上一层的next的左右孩子，存在指向，都不存在才为NULL
           所以当树大的时候，一个节点的next可能指向的离他比较远，所以要遍历确定指向，同时注意要先确定root-right的next，root->left的next需要依赖于right的             next往后找
*/
/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() {}

    Node(int _val, Node* _left, Node* _right, Node* _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/
class Solution {
public:
    Node* connect(Node* root) {
       if(root==NULL)
            return root;
        
        if(root->left!=NULL){
            if(root->right!=NULL)
                root->left->next = root->right;
            else 
            {
                Node* next=root->next;
                while(next) {
                if(next->left!=NULL){
                 
                    root->left->next = next->left;
                    break;
                }
                if(next->right!=NULL)
                {
                    root->left->next = next->right; 
                    break;
                }   
                    next =next->next;
                }
            }
        }
        if(root->right!=NULL )
        {
            Node* next =root->next;
            while(next) {
                if(next->left!=NULL) {
                   
                    root->right->next = next->left;
                    break;
                }
                
                 if(next->right!=NULL)
                {
                    root->right->next = next->right; 
                    break;
                }   
                    next= next->next;
                
            }
                
        }   
           
        
        connect(root->right);
        //先确保 root->right 下的节点的已完全连接，因 root->left 下的节点的连接
        // 需要 root->left.next 下的节点的信息，若 root.right 下的节点未完全连
        // 接（即先对 root.left 递归），则 root->left.next 下的信息链不完整，将
        // 返回错误的信息。可能出现的错误情况如下图所示。此时，底层最左边节点将无
        // 法获得正确的 next 信息：
        //                  o root
        //                 / \
        //     root.left  o —— o  root.right
        //               /    / \
        //              o —— o   o
        //             /        / \
        //            o        o   o 
        
        connect(root->left);
        return root;

    }
};


 

qi_700
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
LeetCode卡片探索-中级算法
屏幕里的日与夜
06-28 444
卡片探索-中级算法数组和字符串三数之和矩阵置零字母异位词分组无重复字符的最长子串最长回文子串递增的三元子序列链表树和图回溯算法排序和搜索动态规划设计问题数学其他 LeetCode上知识卡片之中级算法的刷题记录 数组和字符串 三数之和 把数组排序后，遍历数组，每次固定当前元素，然后用双指针再后续数组里面搜索与它相加为0的元素组合。 class Solution: def threeSum(self, nums: List[int]) -> List[List[int]]: n=l
C++图论SPFA算法例题———————最优贸易
C2020lax的博客
11-09 1213
题目描述： C 国有 n个大城市和m 条道路，每条道路连接这n 个城市中的某两个城市。任意两个城市之间最多只有一条道路直接相连。这m 条道路中有一部分为单向通行的道路，一部分为双向通行的道路，双向通行的道路在统计条数时也计为1 条。C 国幅员辽阔，各地的资源分布情况各不相同，这就导致了同一种商品在不同城市的价格不一定相同。但是，同一种商品在同一个城市的买入价和卖出价始终是相同的。商人阿龙...
c语言 n个点之间的最短距离
03-26
给定平面上的至少n个点（n〉=20），找出其中的一对点，使得在n个点组成的所有点对中，该点对间的距离最小。
平面内有N个点，如何快速求出距离最近的点对？
算法channel
10-16 6668
大家好，我们今天来看一道非常非常经典的算法题——最近点对问题。这个问题经常在各种面试当中出现，难度不低，很少有人能答上来。说实话，我也被问过，因为毫无准备，所以也没有答上来。是的，这道题...
平面n个点的最短连线算法----最短路径
weixin_39481659的博客
07-21 1万+
需求：平面内有多个点，要用一根线逐个连接所有点，每个点不重复。返回排序好的点数组。 思路： 1、先定一个起始点A; 2、计算出起始点A与其他点的距离，比较出距离最短的那个点B； 3、再用点B与其他点（除点A）比较找出距离最短的点C; 4、循环操作直到最后一个点，无需比较，直接找到还没有排序的点，追加在最后即可。 5、然后将所有点循环定为起始点，将每一种点排序组合都加到数组A中，并将这种排序组合所有点连线计算出长度加到数组B中； 6、找出数组B中值最小的下标，到数组A中找对应的点排列组合，.
C语言-最小生成树（Kruskal算法）
热门推荐
Attract's Blog
06-13 1万+
创建边集图（CreateEdgeGraph） 打印图（print） 排序函数（sort） 顶点下标查找函数（LocateVex） 查找双亲函数（FindRoot） 克鲁斯卡尔算法（MiniSpanTree_Kruskal） 克鲁斯卡尔算法 简单的来说就是：每次选取最短边，但不能构成回路。 克鲁斯卡尔算法的关键 用那种方式存储图才合适？ 如果用邻接矩阵和邻接表，每次寻找最短边都要搜索所有边，故邻接矩阵和邻接表均不合适！ 改进图的存储：边集数组。 EdgeGraph中包含了两个数组和顶点数、边.
若干个点的最短路径方式以及绘制连线图（Python）
D2350074007的博客
04-29 5192
1.输入 import matplotlib.pyplot as plt import numpy as np import math from pylab import * print("请输入方格纸的大小a b") ab=np.array((input().split()),int) print("请输入点的个数n：") n=int(input()) print("请输入各个点的横坐标") x=np.array((input().split()),int) print("请输入各个点的纵坐标") y
猜单词leetcode-my-struggle-leetcode:算法打卡日记
06-30
算法打卡日记 ID Title Topic Solution Ideas Java Python Blog 1 两数之和 数组 √ --- √ × × 2 两数相加 链表 √ --- √ × × 3 无重复字符的最长子串 双指针 √ --- √ × × 5 最长回文子串 动态规划 √ ---...
leetcode卡-java-leetcode:leetcode算法学习打卡
07-06
这个“leetcode卡-java-leetcode:leetcode算法学习打卡”项目似乎是一个针对Java开发者的LeetCode学习资源，它可能包含了代码示例、解题策略以及每日学习计划。"系统开源"的标签表明该项目是开放源代码的，这意味着...
leetcode卡-Leetcode-Practice:Leetcode刷题打卡
07-06
2. **主题分类**：LeetCode的题目按照主题分类，如数组、链表、二叉树等，可以按照自己的薄弱领域选择题目进行练习。 3. **定期打卡**：“LeetCode Practice”项目鼓励用户进行每日或每周的刷题打卡，以保持学习的...
leetcode下载--leetcode:-leetcode
06-29
链表-> 哈希表->字符串->栈与队列->树->回溯->贪心->动态规划->图论->高级数据结构，再从简单刷起，做了几个类型题目之后，再慢慢做中等题目、困难题目。 但我能设身处地的感受到：即使有这样一个整体规划，对于一位...
leetcode卡-hello-leetcode:hello-leetcode
07-06
####1.3、链表 ####1.4、哈希表 ####1.5、二叉树 ####1.6、二叉搜索树 ####1.7、N 叉树 ####1.8、前缀树 ###算法 ####2.1、二分查找 ####2.2、递归I ####2.3、数组类算法 ####2.4、查找表类算法 ####2.5、初级算法 #...
含泪总结，五种常见的最短路径算法
john_ashley的博客
09-05 4398
”明月如霜，好风如水，清景无限 “ 总结 总的来说，最短路径是图论的最常见的问题。即在一副有向图（无向图是特殊的有向图，不做考虑。记图中的结点数N ，而边数为 M，边长记为W）中找到其中两点的路径最短值。 壹 * 基础版dijkstra 复杂度 ：O(n * n)，分析可知遍历为n,更新为n。 特点介绍：看复杂度可以知道，此算法仅仅与结点个数有关。那么当图的边数密集，是稠密图时，将会非常适合。而对于稠密图，储存方式最好是邻接矩阵。其中dijkstra算法对应的边长权值都为正数。 代码关键点：
ACM学习：最短路相关总结
qq_62906846的博客
05-22 487
本周主要学习了最短路的相关知识，28道题，大部分都有思路，在根据题解帮助排除误区后A了，一两道由于题目没懂没A。在解题过程中，更全面的了解了最短路径的四种算法。 一.例题解析 最短路径的题大多都是直接给出起点和终点，让我们根据所给数据组成最短路径。而根据题目的具体要求不同，一般用以下四种方法解答： Dijstra算法：常用于单源最短路径的解决，是最常用的方法之一，但是，它虽然简单，却有一些弊端，因此在做题时，常常根据题目需求进行优化，常用的有堆优化等；（但是，有一个缺陷没法弥补，即无法计算有负权值..
数据结构-考研难点代码突破（C++实现有向图最短路径算法（Dijkstra，Floyd-Warshall算法）图解操作细节（引自C语言中文网））
dodamce的博客
01-03 2400
在表 1 的基础上，将顶点 1 作为 “中间顶点”，计算从各个顶点出发途径顶点 1 再到达其它顶点的权值，如果比表 1 中记录的权值更小，证明两个顶点之间存在更短的路径，对表 1 进行更新。当图是带权图时，把从一个顶点a到图中其余任意一个顶点x的一条路径（可能不止一条）所经过边上的权值之和，定义为该路径的带权路径长度，把带权路径长度最短的那条路径称为最短路径.初始化默认值（无穷）3-2-1：权值为 1 + 2 = 3，表 1 中 3-1 的权值为 ∞，3 < ∞；
【数据结构/C语言版】【图】单源最短路径 Dijkstra
智子的博客
12-09 807
Dijkstra 迪杰斯特拉算法 迪杰斯特拉算法(Dijkstra)是由荷兰计算机科学家狄克斯特拉于1959年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法(单源最短路)。 迪杰斯特拉算法主要特点是从起始点开始，采用贪心算法的策略，每次遍历到始点距离最近且未访问过的顶点的邻接节点，直到扩展到终点为止。 朴素Dijkstra时间复杂度o(n^2)。 优先队列优化Dijkstra时间复杂度为 o(m log n)。 测试数据 1 6 8 1 2 3 4 5 6 1 3 10 1 5 30
贪心算法题解（最小生成树专题）
ZY的博客
11-25 933
A. 最小生成树 Description 在一张图上有N个点，点与点之间的连接的花费都已经告诉你了，请你设计一下，如何解决这个“最小生成树”的问题。要求用prim方法求解。 Input 首先输入一个数字N（0〈=N〈=100） ​ 然后输入一个N*N的矩阵 其中第i行第j列的数字k表示从点i到点j需要的花费。 Output 一个数字，最少需要多少花费才能使得整张图任意两点都直接或者间接连通（也就是最小生成树的权） Sample Input 5 0 41 67 34 0 41 0 69 24 78 67
写出一段代码将链表中的两个节点位置互换位置_链表常见操作和15道常见面试题
weixin_39767983的博客
12-02 1822
什么是单链表 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)，简单来说链表并不像数组那样将数组存储在一个连续的内存地址空间里，它们可以不是连续的因为他们每个节点保存着下一个节点的引用（地址），所以较之数组来说这是一个优势。对于单链表的一个节点我们经常使用下边这种代码表示：public c...
算法 - 链表移动k个元素
liqingbing12的专栏
06-27 1174
题目 给定一个链表和一个整数K，要求将链表当中的所有元素向右移动K位。 示例 Input: 1->2->3->4->5->NULL, k = 2 Output: 4->5->1->2->3->NULL Explanation: rotate 1 steps to the right: 5->1->2->3->4->NULL rotate 2 steps to the right: 4->5-&gt
leetcoder题目java_LeetCode算法题-Toeplitz Matrix（Java实现）
最新发布
05-29
好的，您的问题是关于 `Toeplitz Matrix` 这道 LeetCode 算法题的 Java 实现。这道题的题目描述是给定一个矩阵，判断该矩阵是否为 Toeplitz 矩阵。Toeplitz 矩阵指的是从左上角到右下角的对角线上的元素都相等。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值