leetcode mergeKsortedlink

代码:这个代码是有问题的,问题的产生是map中不能存放相同的值。

  1 #include<iostream>
  2 #include<vector>
  3 #include<cmath>
  4 #include<map>
  5
  6 using namespace std;
  7
  8 typedef struct ListNode {
  9     int val;
 10     ListNode *next;
 11     ListNode(int x) : val(x), next(NULL) {}
 12 }ListNode;
 13
 14 inline int left(int x)
 15 {
 16     return 2 * x + 1;
 17 }
 18
 19 inline int right(int x)
 20 {
 21     return 2 * x + 2;
 22 }
 23
 24 void swap(int &x, int &y)
 25 {
 26     int c = x;
 27     x = y;
 28     y = c;
 29 }
 30
 31 int QQ;
 32
 33 //    以i节点为根节点进行,堆的维护;假设i节点下面的节点都是堆了。
 34 void MaxHeap(int a[], int i, int k,int ok)
 35 {
 36     int l = left(i);
 37     int r = right(i);
 38     int smallest = i;
 39     if (l < k  && a[l] < a[i])
 40     {
 41         smallest = l;
 42     }
 43     if (r<k&&a[r] < a[smallest])
 44     {
 45         smallest = r;
 46     }
 47     if (i == smallest)
 48     {
 49         return;
 50     }
 51     else
 52     {
 53         swap(a[smallest], a[i]);
 54         return MaxHeap(a, smallest, k, 1);
 55     }
 56 }
 57
 58 ListNode *mergeKLists(vector<ListNode *> &lists) {
 59     int k = lists.size();
 60     int *flag = new int[k];    //    标志位
 61     int *a = new int[k];
 62     ListNode *head;
 63     map<int, int> cmap;
 64     int n = k;
 65     ListNode **p = (ListNode**)malloc(sizeof(ListNode*)*k);
 66     for (int i = 0; i < k; i++)
 67     {
 68         p[i] = lists[i];
 69         a[i] = p[i]->val;
 70         cmap.insert(make_pair(a[i], i));
 71         if (p[i] == NULL)
 72         {
 73             flag[i] = 0;
 74         }
 75         else
 76         {
 77             flag[i] = 1;
 78         }
 79     }
 80     MaxHeap(a, 0, k,0);
 81     int t = cmap[a[0]];
 82     head = lists[t];
 83     ListNode *m = lists[t];
 84     p[t] = p[t]->next;
 85     while (n != 1)
 86     {
 87         n = k;
 88         for (int i = 0; i < k; i++)
 89         {
 90             if (p[i] == NULL)
 91             {
 92                 flag[i] = 0;
 93                 n--;
 94             }
 95         }
 96         if (flag[t] == 0)
 97         {
 98             a[0] = a[n];
 99             MaxHeap(a, 0, n, 0);
100             t = cmap[a[0]];
101             m->next = p[t];
102             m = m->next;
103             p[t] = p[t]->next;
104         }
105         else
106         {
107             a[0] = p[t]->val;
108             cmap.insert(make_pair(a[0], t));
109             MaxHeap(a, 0, n, 0);
110             t = cmap[a[0]];
111             m->next = p[t];
112             m = m->next;
113             p[t] = p[t]->next;
114         }
115     }
116     ListNode * last;
117     for (int i = 0; i < k; i++)
118     {
119         if (p[i] != NULL)
120         {
121             last = p[i];
122         }
123     }
124     m->next = last;
125     return head;
126 }
127
128 int main()
129 {
130     /*int a[] = {3,1,4,2,3,5,6};
131     MaxHeap(a, 0, 7, 0);
132     cout << "标识"<<QQ << endl;
133     for (int i = 0; i < 7; i++)
134     {
135         cout << a[i] << endl;
136     }*/
137     int a[6] = {1,3,9,12, 37, 56};
138     int b[7] = {2,5, 8, 11, 35,66,77};
139     int c[4] = { 4, 7, 10, 34 };
140     vector<ListNode*> p;
141
142     ListNode *temp = (ListNode *)malloc(sizeof(ListNode));
143     ListNode *head = temp;
144     for (int i = 0; i < 6; i++)
145     {
146         temp->val = a[i];
147         if (i != 5)
148             temp->next = (ListNode *)malloc(sizeof(ListNode));
149         else
150             temp->next = NULL;
151         temp = temp->next;
152     }
153     ListNode *temp1 = (ListNode *)malloc(sizeof(ListNode));
154     ListNode *head1 = temp1;
155     for (int i = 0; i < 7; i++)
156     {
157         temp1->val = b[i];
158         if (i != 6)
159             temp1->next = (ListNode *)malloc(sizeof(ListNode));
160         else
161             temp1->next = NULL;
162         temp1 = temp1->next;
163     }
164
165     ListNode *temp2 = (ListNode *)malloc(sizeof(ListNode));
166     ListNode *head2 = temp2;
167     for (int i = 0; i < 4; i++)
168     {
169         temp2->val = c[i];
170         if (i != 3)
171             temp2->next = (ListNode *)malloc(sizeof(ListNode));
172         else
173             temp2->next = NULL;
174         temp2 = temp2->next;
175     }
176
177     p.push_back(head);
178     p.push_back(head1);
179     p.push_back(head2);
180     for (ListNode * temp = head; temp != NULL; temp = temp->next)
181     {
182         cout << temp->val << endl;
183     }
184     for (ListNode * temp = mergeKLists(p); temp != NULL; temp = temp->next)
185     {
186     cout << temp->val << endl;
187     }
188 }
时间: 2024-09-29 16:20:22

leetcode mergeKsortedlink的相关文章

[LeetCode] 349 Intersection of Two Arrays &amp; 350 Intersection of Two Arrays II

这两道题都是求两个数组之间的重复元素,因此把它们放在一起. 原题地址: 349 Intersection of Two Arrays :https://leetcode.com/problems/intersection-of-two-arrays/description/ 350 Intersection of Two Arrays II:https://leetcode.com/problems/intersection-of-two-arrays-ii/description/ 题目&解法

LeetCode 442. Find All Duplicates in an Array (在数组中找到所有的重复项)

Given an array of integers, 1 ≤ a[i] ≤ n (n = size of array), some elements appear twice and others appear once. Find all the elements that appear twice in this array. Could you do it without extra space and in O(n) runtime? Example: Input: [4,3,2,7,

LeetCode OJ - Sum Root to Leaf Numbers

这道题也很简单,只要把二叉树按照宽度优先的策略遍历一遍,就可以解决问题,采用递归方法越是简单. 下面是AC代码: 1 /** 2 * Sum Root to Leaf Numbers 3 * 采用递归的方法,宽度遍历 4 */ 5 int result=0; 6 public int sumNumbers(TreeNode root){ 7 8 bFSearch(root,0); 9 return result; 10 } 11 private void bFSearch(TreeNode ro

LeetCode OJ - Longest Consecutive Sequence

这道题中要求时间复杂度为O(n),首先我们可以知道的是,如果先对数组排序再计算其最长连续序列的时间复杂度是O(nlogn),所以不能用排序的方法.我一开始想是不是应该用动态规划来解,发现其并不符合动态规划的特征.最后采用类似于LRU_Cache中出现的数据结构(集快速查询和顺序遍历两大优点于一身)来解决问题.具体来说其数据结构是HashMap<Integer,LNode>,key是数组中的元素,所有连续的元素可以通过LNode的next指针相连起来. 总体思路是,顺序遍历输入的数组元素,对每个

LeetCode OJ - Surrounded Regions

我觉得这道题和传统的用动规或者贪心等算法的题目不同.按照题目的意思,就是将被'X'围绕的'O'区域找出来,然后覆盖成'X'. 那问题就变成两个子问题: 1. 找到'O'区域,可能有多个区域,每个区域'O'都是相连的: 2. 判断'O'区域是否是被'X'包围. 我采用树的宽度遍历的方法,找到每一个'O'区域,并为每个区域设置一个value值,为0或者1,1表示是被'X'包围,0则表示不是.是否被'X'包围就是看'O'区域的边界是否是在2D数组的边界上. 下面是具体的AC代码: class Boar

LeetCode 10. Regular Expression Matching

https://leetcode.com/problems/regular-expression-matching/description/ Implement regular expression matching with support for '.' and '*'. '.' Matches any single character. '*' Matches zero or more of the preceding element. The matching should cover

(leetcode题解)Pascal&#39;s Triangle

Pascal's Triangle  Given numRows, generate the first numRows of Pascal's triangle. For example, given numRows = 5,Return [ [1], [1,1], [1,2,1], [1,3,3,1], [1,4,6,4,1] ] 题意实现一个杨辉三角. 这道题只要注意了边界条件应该很好实现出来,C++实现如下 vector<vector<int>> generate(int

[LeetCode]Count Primes

题目:Count Primes 统计1-n的素数的个数. 思路1: 通常的思想就是遍历(0,n)范围内的所有数,对每个数i再遍历(0,sqrt(i)),每个除一遍来判断是否为素数,这样时间复杂度为O(n*sqrt(n)). 具体实现不在贴代码,过程很简单,两重循环就可以解决.但是效率很差,n较大时甚至会花几分钟才能跑完. 思路2: 用埃拉特斯特尼筛法的方法来求素数,时间复杂度可以达到O(nloglogn). 首先开一个大小为n的数组prime[],从2开始循环,找到一个质数后开始筛选出所有非素数

[LeetCode]Repeated DNA Sequences

题目:Repeated DNA Sequences 给定包含A.C.G.T四个字符的字符串找出其中十个字符的重复子串. 思路: 首先,string中只有ACGT四个字符,因此可以将string看成是1,3,7,20这三个数字的组合串: 并且可以发现{ACGT}%5={1,3,2,0};于是可以用两个位就能表示上面的四个字符: 同时,一个子序列有10个字符,一共需要20bit,即int型数据类型就能表示一个子序列: 这样可以使用计数排序的思想来统计重复子序列: 这个思路时间复杂度只有O(n),但是