15个使用频率极高的基础算法题（附完整代码）

最新推荐文章于 2022-08-30 22:13:56 发布
最新推荐文章于 2022-08-30 22:13:56 发布
阅读量693 收藏
点赞数
分类专栏： c++ 文章标签： 算法

  1. 合并排序，将两个已经排序的数组合并成一个数组，其中一个数组能容下两个数组的所有元素

    一般来说，合并两个已经有序的数组，首先是开一个能存的下两个数组的第三个数组，但是题目中已经说了，其中一个数组能全部存的下，显然就不应该浪费空间了。
    从前往后扫的话，数据要存在大数组的前头，这样每次要把大数组的元素一次后移一位，显然不是什么好主意，所以我们从后往前存。

    [cpp]  view plain copy print ?
    1. #include<iostream>  
    2. #include<cstdlib>  
    3. using namespace std;  
    4.   
    5. int cc[10];  
    6. int tt[5];  
    7.   
    8. void init()  
    9. {  
    10.     srand((unsigned)time(NULL));  
    11.     int num = rand() % 5;  
    12.     for(int i = 0; i < 5; i++)  
    13.     {  
    14.         cc[i] = num;  
    15.         num += rand() % 10 + 1;  
    16.     }  
    17.     num = rand() % 5;  
    18.     for(int i = 0; i < 5; i++)  
    19.     {  
    20.         tt[i] = num;  
    21.         num += rand() % 10 + 1;  
    22.     }  
    23. }  
    24.   
    25. void merge()  
    26. {  
    27.     int i = 4, j = 4, idx = 9;  
    28.     while(i>=0 && j>=0)  
    29.     {  
    30.         if(cc[i] > tt[j])  
    31.             cc[idx--] = cc[i--];  
    32.         else  
    33.             cc[idx--] = tt[j--];  
    34.     }  
    35.     while(i>=0)  
    36.         cc[idx--] = cc[i--];  
    37.     while(j>=0)  
    38.         cc[idx--] = tt[j--];  
    39. }  
    40.   
    41. int main()  
    42. {  
    43.     init();  
    44.     for(int i = 0; i < 5; i++)  
    45.         printf("%d ", cc[i]);  
    46.     putchar(10);  
    47.     for(int i = 0; i < 5; i++)  
    48.         printf("%d ", tt[i]);  
    49.     putchar(10);  
    50.   
    51.     merge();  
    52.   
    53.     for(int i = 0; i < 10; i++)  
    54.         printf("%d ", cc[i]);  
    55.     putchar(10);  
    56.   
    57.     getchar();  
    58.     return 0;  
    59. }  

  2. 合并两个已经排序的单链表

    不能创建第三条链表，用上两种办法进行合并

    [cpp]  view plain copy print ?
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. struct node{  
    5.     int data;  
    6.     node *next;  
    7. };  
    8.   
    9. void CreateNode(node *head) // 创建带有头结点的有序单链表  
    10. {  
    11.     node *s = head;  
    12.     int val = rand() % 5 + 1;  
    13.     for (int i = 0; i < 5; i++)  
    14.     {  
    15.         val += rand() % 5 + 1;  
    16.         node *t = new node;  
    17.         t->data = val;  
    18.         t->next = NULL;  
    19.         s = s->next = t;  
    20.     }  
    21. }  
    22.   
    23. void PrintNode(node *head)  
    24. {  
    25.     node *s = head;  
    26.     while (s = s->next)  
    27.         printf("%d ", s->data);  
    28.     putchar(10);  
    29. }  
    30.   
    31. node* Merge_1(node *head1, node *head2) // 顺序扫描  
    32. {  
    33.     node *i = head1->next;  
    34.     node *j = head2->next;  
    35.     node *cc = new node;  
    36.     node *s = cc;  
    37.     while(i && j)  
    38.     {  
    39.         if(i->data < j->data)  
    40.         {  
    41.             s = s->next = i;  
    42.             i = i->next;  
    43.         }  
    44.         else  
    45.         {  
    46.             s = s->next = j;  
    47.             j = j->next;  
    48.         }  
    49.     }  
    50.     if(i)  
    51.         s->next = i;  
    52.     else  
    53.         s->next = j;  
    54.     return cc;  
    55. }  
    56.   
    57. node* Merge_2(node *head1, node *head2) // 递归法  
    58. {  
    59.     if(head1 == NULL)  
    60.         return head2;  
    61.     if(head2 == NULL)  
    62.         return head1;  
    63.     node *cc = NULL;  
    64.     if(head1->data < head2->data)  
    65.     {  
    66.         cc = head1;  
    67.         cc->next = Merge_2(head1->next, head2);  
    68.     }  
    69.     else  
    70.     {  
    71.         cc = head2;  
    72.         cc->next = Merge_2(head1, head2->next);  
    73.     }  
    74.     return cc;  
    75. }  
    76.   
    77. int main()  
    78. {  
    79.     srand((unsigned)time(NULL));  
    80.       
    81.     node *LinkList1 = new node, *LinkList2 = new node;  
    82.     CreateNode(LinkList1);  
    83.     CreateNode(LinkList2);  
    84.     PrintNode(LinkList1);  
    85.     PrintNode(LinkList2);  
    86.   
    87.     // LinkList1 = Merge_1(LinkList1, LinkList2);  
    88.     LinkList1->next = Merge_2(LinkList1->next, LinkList2->next);  
    89.     PrintNode(LinkList1);   // 合并后的链表存在1中  
    90.   
    91.     getchar();  
    92.     return 0;  
    93. }  

  3. 倒序打印一个单链表

    [cpp]  view plain copy print ?
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. struct node{  
    5.     int data;  
    6.     node *next;  
    7. };  
    8.   
    9. void CreateNode(node *&head) // 创建不带头结点的有序单链表  
    10. {  
    11.     head = new node;  
    12.     head->data = rand() % 5 + 1;  
    13.     node *s = head, *t = NULL;  
    14.     for(int i = 0; i < 5; i++)  
    15.     {  
    16.         t = new node;  
    17.         t->data = s->data + rand() % 5 + 1;  
    18.         s = s->next = t;  
    19.     }  
    20.     s->next = NULL;  
    21. }  
    22.   
    23. void PrintNode(node *head)  
    24. {  
    25.     node *s = head;  
    26.     while (s != NULL)  
    27.     {  
    28.         printf("%d ", s->data);  
    29.         s = s->next;  
    30.     }  
    31.     putchar(10);  
    32. }  
    33.   
    34. void PrintNode_Reverse(node *head)  
    35. {  
    36.     if(head->next != NULL)  
    37.         PrintNode_Reverse(head->next);  
    38.     printf("%d ", head->data);  
    39. }  
    40.   
    41. int main()  
    42. {  
    43.     srand((unsigned)time(NULL));  
    44.       
    45.     node *LinkList;  
    46.   
    47.     CreateNode(LinkList);  
    48.     PrintNode(LinkList);  
    49.     PrintNode_Reverse(LinkList);  
    50.   
    51.     putchar(10);  
    52.     getchar();  
    53.     return 0;  
    54. }  

  4. 给定一个单链表的头指针和一个指定节点的指针，在O(1)时间删除该节点

    参见博客：如何在O(1)的时间里删除单链表的结点

  5. 找到链表倒数第K个节点

    设两个指针，一个先向前走K步，然后两个指针同步移动，等先走的指针走到了末尾，后走的指针就在倒数第K个位置了。

    [cpp]  view plain copy print ?
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. struct node{  
    5.     int data;  
    6.     node *next;  
    7. };  
    8.   
    9. void CreateNode(node *&head) // 创建不带头结点的有序单链表  
    10. {  
    11.     head = new node;  
    12.     head->data = rand() % 5 + 1;  
    13.     node *s = head, *t = NULL;  
    14.     for(int i = 0; i < 10; i++)  
    15.     {  
    16.         t = new node;  
    17.         t->data = s->data + rand() % 5 + 1;  
    18.         s = s->next = t;  
    19.     }  
    20.     s->next = NULL;  
    21. }  
    22.   
    23. void PrintNode(node *head)  
    24. {  
    25.     node *s = head;  
    26.     while (s != NULL)  
    27.     {  
    28.         printf("%d ", s->data);  
    29.         s = s->next;  
    30.     }  
    31.     putchar(10);  
    32. }  
    33.   
    34. void find(node *head, int num)  
    35. {  
    36.     node *s = head, *t = head;  
    37.     for(int i = 0; i < num; i++)  
    38.         t = t->next;  
    39.     while(t)  
    40.     {  
    41.         s = s->next;  
    42.         t = t->next;  
    43.     }  
    44.     printf("place: %dth value:%d\n", num, s->data);  
    45. }  
    46.   
    47. int main()  
    48. {  
    49.     srand((unsigned)time(NULL));  
    50.       
    51.     node *LinkList;  
    52.   
    53.     CreateNode(LinkList);  
    54.     PrintNode(LinkList);  
    55.     find(LinkList, 5);  
    56.     find(LinkList, 3);  
    57.   
    58.     putchar(10);  
    59.     getchar();  
    60.     return 0;  
    61. }  

  6. 反转单链表

    用递归与非递归两种方法，注意检查链表只有一个结点的时候反转函数不会出错

    [cpp]  view plain copy print ?
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. struct node{  
    5.     int data;  
    6.     node *next;  
    7. };  
    8.   
    9. void CreateNode(node *&head) // 创建不带头结点的有序单链表  
    10. {  
    11.     head = new node;  
    12.     head->data = rand() % 5 + 1;  
    13.     node *s = head, *t = NULL;  
    14.     for(int i = 0; i < 10; i++)  
    15.     {  
    16.         t = new node;  
    17.         t->data = s->data + rand() % 5 + 1;  
    18.         s = s->next = t;  
    19.     }  
    20.     s->next = NULL;  
    21. }  
    22.   
    23. void PrintNode(node *head)  
    24. {  
    25.     node *s = head;  
    26.     while (s != NULL)  
    27.     {  
    28.         printf("%d ", s->data);  
    29.         s = s->next;  
    30.     }  
    31.     putchar(10);  
    32. }  
    33.   
    34. node* Reverse_1(node *head)  // 非递归  
    35. {  
    36.     node *s = head, *t = head->next;  
    37.     s->next = NULL;  
    38.     while(t != NULL)  
    39.     {  
    40.         node *r = t->next;  
    41.         t->next = s;  
    42.         s = t;  
    43.         t = r;  
    44.     }  
    45.     return s;  
    46. }  
    47.   
    48. void Reverse_2(node *front, node *n, node *&head)  // 递归  
    49. {  
    50.     front->next = NULL;  
    51.     if(n != NULL)  
    52.         head = n;  
    53.     if(n != NULL && n->next != NULL)  
    54.         Reverse_2(n, n->next, head);  
    55.     if(n != NULL)  
    56.         n->next = front;  
    57. }  
    58.   
    59. int main()  
    60. {  
    61.     srand((unsigned)time(NULL));  
    62.       
    63.     node *LinkList;  
    64.   
    65.     CreateNode(LinkList);  
    66.     PrintNode(LinkList);  
    67.     LinkList = Reverse_1(LinkList);  
    68.     // Reverse_2(LinkList, LinkList->next, *&LinkList);  
    69.     PrintNode(LinkList);  
    70.   
    71.     putchar(10);  
    72.     getchar();  
    73.     return 0;  
    74. }  

  7. 通过两个栈实现一个队列

    参见博客：用两个栈实现队列

  8. 二分查找

    [cpp]  view plain copy print ?
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. void BinarySearch(int cc[], int num, int key)// 数组, 数组个数, 待查数字  
    5. {  
    6.     int i = 0, j = num;  
    7.     int cnt = 0, mid = 0;  
    8.     while(i < j)  
    9.     {  
    10.         cnt++;  
    11.         mid = (i + j) >> 1;  
    12.         if(cc[mid] == key)  
    13.         {  
    14.             printf("%d %s, index: %d\n", cnt, cnt==1?"time":"times", mid);  
    15.             return;  
    16.         }  
    17.         else if(cc[mid] < key)  
    18.             i = mid;  
    19.         else  
    20.             j = mid;  
    21.     }  
    22. }  
    23.   
    24. int main()  
    25. {  
    26.     int cc[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};  
    27.     BinarySearch(cc, 10, 3);  
    28.   
    29.     getchar();  
    30.     return 0;  
    31. }  

  9. 快速排序

    两种略微有些不一样的快排（传入参数不同）

    [cpp]  view plain copy print ?
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. int cc[10];  
    5.   
    6. void init()  
    7. {  
    8.     srand((unsigned)time(NULL));  
    9.     for(int i = 0; i < 10; i++)  
    10.     {  
    11.         int idx = rand()%10;  
    12.         while(cc[idx])  
    13.             idx = rand()%10;  
    14.         cc[idx] = i+1;  
    15.     }  
    16. }  
    17.   
    18. void show()  
    19. {  
    20.     for(int i = 0; i < 10; i++)  
    21.         printf("%d ", cc[i]);  
    22.     putchar(10);  
    23. }  
    24.   
    25. void QuickSort_1(int cc[], int num)  
    26. {  
    27.     int s = 0, t = num-1;  
    28.     int base = cc[0];  
    29.     if(num <= 1)  
    30.         return;  
    31.     while(s < t)  
    32.     {  
    33.         while(t > s && cc[t] >= base)  
    34.             t--;  
    35.         cc[s] = cc[t];  
    36.         while(s < t && cc[s] <= base)  
    37.             s++;  
    38.         cc[t] = cc[s];  
    39.     }  
    40.     cc[s] = base;  
    41.     QuickSort(cc, s);  
    42.     QuickSort(cc+s+1, num-s-1);  
    43. }  
    44.   
    45. void QuickSort_2(int cc[], int l, int r)  
    46. {  
    47.     if(l >= r)  
    48.         return;  
    49.     int s = l, t = r;  
    50.     int base = cc[l];  
    51.     while(s < t)  
    52.     {  
    53.         while(t > s && cc[t] >= base)  
    54.             t--;  
    55.         cc[s] = cc[t];  
    56.         while(s < t && cc[s] <= base)  
    57.             s++;  
    58.         cc[t] = cc[s];  
    59.     }  
    60.     cc[s] = base;  
    61.     QuickSort_2(cc, l, s-1);  
    62.     QuickSort_2(cc, s+1, r);  
    63. }  
    64.   
    65. int main()  
    66. {  
    67.     init();  
    68.     show();  
    69.     //QuickSort_1(cc, sizeof(cc)/sizeof(int));  
    70.     QuickSort_2(cc, 0, sizeof(cc)/sizeof(int)-1);  
    71.     show();  
    72.   
    73.     getchar();  
    74.     return 0;  
    75. }  

  10. 获得一个int型的数中二进制中的个数

    没明白这个题目的意思，我们就理解成两个小题好了：
    （1）求一个int型数字的二进制位数，如6->110->3位数
    （2）求这个int型数字的二进制中'1'的个数

    [cpp]  view plain copy print ?
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. int main()  
    5. {  
    6.     int num;  
    7.     while(~scanf("%d", &num))  
    8.     {  
    9.         int bits = 0, cnt = 0;  
    10.         int val = num;  
    11.         while(val)  
    12.         {  
    13.             if(val & 1)  
    14.                 cnt++;  
    15.             bits++;  
    16.             val>>=1;  
    17.         }  
    18.         printf("%d has %d bit and %d '1' in binary\n", num, bits, cnt);  
    19.     }  
    20.     return 0;  
    21. }  

  11. 输入一个数组，实现一个函数，让所有奇数都在偶数前面

    [cpp]  view plain copy print ?
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. int cc[10];  
    5.   
    6. void init()  
    7. {  
    8.     srand((unsigned)time(NULL));  
    9.     for(int i = 0; i < 10; i++)  
    10.     {  
    11.         int idx = rand()%10;  
    12.         while(cc[idx])  
    13.             idx = rand()%10;  
    14.         cc[idx] = i+1;  
    15.     }  
    16. }  
    17.   
    18. void show()  
    19. {  
    20.     for(int i = 0; i < 10; i++)  
    21.         printf("%d ", cc[i]);  
    22.     putchar(10);  
    23. }  
    24.   
    25. void Sort(int cc[], int size)  
    26. {  
    27.     int s = 0, t = size-1;  
    28.     while(s < t)  
    29.     {  
    30.         while(s < t && (cc[s]&1))  
    31.             s++;  
    32.         while(t > s && !(cc[t]&1))  
    33.             t--;  
    34.         cc[s] ^= cc[t];  
    35.         cc[t] ^= cc[s];  
    36.         cc[s] ^= cc[t];  
    37.     }  
    38. }  
    39.   
    40. int main()  
    41. {  
    42.     init();  
    43.     show();  
    44.     Sort(cc, sizeof(cc)/sizeof(int));  
    45.     show();  
    46.   
    47.     getchar();  
    48.     return 0;  
    49. }  

  12. 判断一个字符串是否是另一个字符串的子串

    经典问题，用KMP算法。
    [cpp]  view plain copy print ?
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. char t[1000];  
    5. char p[100];  
    6. int f[100];  
    7.   
    8. int cnt = 0;  
    9.   
    10. void KMP()  //需要使用的参数是char t[]长串, char p[]模式串.  
    11. {  
    12.     int n = strlen(t);  
    13.     int m = strlen(p);  
    14.     /计算模式串的失配边  
    15.     f[0] = f[1] = 0;  
    16.     for(int i = 1; i < m; i ++)  
    17.     {  
    18.         int j = f[i];  
    19.         while(j && p[i] != p[j])j = f[j];  
    20.         f[i+1] = p[i] == p[j]?j+1:0;  
    21.     }  
    22.   
    23.     int j = 0;  
    24.     for(int i = 0; i < n; i ++)  
    25.     {  
    26.         while(j && t[i] != p[j]) j = f[j];  
    27.         if(p[j] == t[i])j ++;  
    28.         if(j == m)    //匹配成功  
    29.             cnt ++;  
    30.     }  
    31. }  
    32.   
    33.   
    34. int main()  
    35. {  
    36.     cnt = 0;  
    37.     gets(t);  
    38.     gets(p);  
    39.     KMP();  
    40.     if(cnt >= 1)  
    41.         printf("match!\n");  
    42.     else  
    43.         printf("not match!\n");  
    44.     getchar();  
    45.     return 0;  
    46. }  

  13. 把一个int型数组中的数字拼成一个串，这个串代表的数字最小

    关键就是要把int数组排个序，排序的cmp代码应该这样：如果两个数是A和B，那么应该比较AB和BA的大小，例如12、15，就要比较1215和1512的大小了。所以为了方便我们把int先转成char型，这样比较的时候直接strcat非常方便。
    [cpp]  view plain copy print ?
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. void CreateArray(int *cc, int num)  
    5. {  
    6.     srand((unsigned int)time(NULL));  
    7.     for(int i = 0; i < num; i++)  
    8.         cc[i] = rand() % 50;  
    9. }  
    10.   
    11. int cmp(const void *a, const void *b)  
    12. {  
    13.     char *s1 = new char[10];  
    14.     char *s2 = new char[10];  
    15.     strcpy(s1, *(char**)a);  
    16.     strcat(s1, *(char**)b);  
    17.   
    18.     strcpy(s2, *(char**)b);  
    19.     strcat(s2, *(char**)a);  
    20.     return strcmp(s1, s2);  
    21. }  
    22.   
    23. void ConvertToMinString(int *cc, int len)  
    24. {  
    25.     char** str = (char**)new int[len];  
    26.     for(int i = 0; i < len; i++)  
    27.     {  
    28.         str[i] = new char[5];  
    29.         sprintf(str[i], "%d", cc[i]);  
    30.     }  
    31.     qsort(str, len, sizeof(char*), cmp);  
    32.     for(int i = 0; i < len; i++)  
    33.         printf("%s ", str[i]);  
    34.     putchar(10);  
    35. }  
    36.   
    37. int main()  
    38. {  
    39.     int cc[5];  
    40.     CreateArray(cc, 5);  
    41.     ConvertToMinString(cc, 5);  
    42.     getchar();  
    43.     return 0;  
    44. }  

  14. 输入一颗二叉树，输出它的镜像（每个节点的左右子节点交换位置）


    用上递归和非递归两种方法。
    [cpp]  view plain copy print ?
    1. #include <iostream>  
    2. #include <queue>  
    3. using namespace std;  
    4.   
    5. struct node{  
    6.     int val;  
    7.     node *left;  
    8.     node *right;  
    9. };  
    10.   
    11. void insert(node *&root, int data)  
    12. {  
    13.     if(root == NULL)  
    14.     {  
    15.         root = new node;  
    16.         root->val = data;  
    17.         root->left = root->right = NULL;  
    18.         return;  
    19.     }  
    20.     if(root->val > data)  
    21.         insert(root->left, data);  
    22.     else  
    23.         insert(root->right, data);  
    24. }  
    25.   
    26. node* build()  
    27. {  
    28.     node *root = NULL;  
    29.     insert(root, 10);  
    30.     for(int i = 8; i <= 12; i++)  
    31.     {  
    32.         if(i == 10)continue;  
    33.         insert(root, i);  
    34.     }  
    35.     return root;  
    36. }  
    37.   
    38. void showTree(node *root)  
    39. {  
    40.     if(root == NULL) return;  
    41.     printf("%d ", root->val);  
    42.     showTree(root->left);  
    43.     showTree(root->right);  
    44. }  
    45.   
    46. void Mirror_1(node *&root)    // 递归方法  
    47. {  
    48.     if(root == NULL) return;  
    49.     node *t = root->left;  
    50.     root->left = root->right;  
    51.     root->right = t;  
    52.     Mirror_1(root->left);  
    53.     Mirror_1(root->right);  
    54. }  
    55.   
    56. void Mirror_2(node *&root)     // 非递归方法  
    57. {  
    58.     queue<node*> q;  
    59.     if(root != NULL)  
    60.         q.push(root);  
    61.     while(!q.empty())  
    62.     {  
    63.         node *n = q.front();  
    64.         q.pop();  
    65.         node *t = n->left;  
    66.         n->left = n->right;  
    67.         n->right = t;  
    68.         if(n->left != NULL)  
    69.             q.push(n->left);  
    70.         if(n->right != NULL)  
    71.             q.push(n->right);  
    72.     }  
    73. }  
    74.   
    75. int main()  
    76. {  
    77.     node *root = build();  
    78.     showTree(root);putchar(10);  
    79.   
    80.     Mirror_1(root);  
    81.     showTree(root);putchar(10);  
    82.   
    83.     Mirror_2(root);  
    84.     showTree(root);putchar(10);  
    85.       
    86.     getchar();  
    87.     return 0;  
    88. }  

  15. 输入两个链表，找到它们第一个公共节点

    也就是说这两个链表的形状就像“Y”一样。
    我想到了两种办法：
    ①两个链表先分别枚举一遍，计算出两个链表的长度，假设是N和M，假设长链是N的长度，即N>=M，让长链先走N-M步，短链指针先不走，这样两个指针到结尾的距离都相同了，然后两个指针一边同步走一边进行比较，什么时候两个指针相同，当前节点就是第一个公共节点了。时间复杂度：O(n+m)
    ②设一个map或者其他键值对（哈希表），然后第一个链表走一步，根据其地址或主键建立索引，第二个链表走一步，根据其地址或主键建立索引，两个链表在遍历的时候分别去检索索引，什么时候发现已经记录了，那么当前节点就是第一个公共节点了。假设两个链表在相交之前的长度分别是N和M，则空间复杂度是O(max(n, m)*2)，其时间复杂度是O(max(n, m) * 2)。
    相比之下我认为②要好的多，毕竟时间相比于空间重要太多了。所以下面我给出了②的代码，用地址作为索引。其实我觉得如何创建这样交叉的链表和如何存储指针地址也可以作为一个题目哈。
    [cpp]  view plain copy print ?
    1. #include <iostream>  
    2. #include <map>  
    3. using namespace std;  
    4.   
    5. struct node{  
    6.     int val;  
    7.     node *next;  
    8. };  
    9.   
    10. node* buildFirTree()    // 第一个链表有20个节点  
    11. {  
    12.     node *root = new node;  
    13.     root->val = 1;  
    14.   
    15.     node *s = root, *t = root;  
    16.     for(int i = 2; i <= 20; i++)  
    17.     {  
    18.         t = new node;  
    19.         t->val = i;  
    20.         s = s->next = t;  
    21.     }  
    22.     s->next = NULL;  
    23.     return root;  
    24. }  
    25.   
    26. node* buildSecTree(node *firnode)// 第二个链表创建5个结点，然后接到第一个链表的第8个结点上  
    27. {  
    28.     node *root = new node;  
    29.     root->val = 11;  
    30.     node *s = root, *t = root;  
    31.     for(int i = 2; i <= 5; i++)  
    32.     {  
    33.         t = new node;  
    34.         t->val = 10 + i;  
    35.         s = s->next = t;  
    36.     }  
    37.     node *k = firnode;  
    38.     for(int i = 0; i < 7; i++)  
    39.         k = k->next;  
    40.     s->next = k;  
    41.     return root;  
    42. }  
    43.   
    44. void disp(node *root)  
    45. {  
    46.     node *t = root;  
    47.     while(t)  
    48.     {  
    49.         printf("%d ", t->val);  
    50.         t = t->next;  
    51.     }  
    52.     putchar(10);  
    53. }  
    54.   
    55. node *GetFirstCommonNode(node *fir, node *sec)  
    56. {  
    57.     map<long, bool> mp;  
    58.     mp.clear();  
    59.   
    60.     while(fir && sec)  
    61.     {  
    62.         if(mp[(long)fir] == true)  
    63.             return fir;  
    64.         mp[(long)fir] = true;  
    65.         fir = fir->next;  
    66.   
    67.         if(mp[(long)sec] == true)  
    68.             return sec;  
    69.         mp[(long)sec] = true;  
    70.         sec = sec->next;  
    71.     }  
    72.     return NULL;  
    73. }  
    74.   
    75. int main()  
    76. {  
    77.     node *fir = buildFirTree();  
    78.     printf("First linklist: ");disp(fir);  
    79.     node *sec = buildSecTree(fir);  
    80.     printf("second linklist: ");disp(sec);  
    81.   
    82.     node *common = GetFirstCommonNode(fir, sec);  
    83.     if(common != NULL)  
    84.         printf("common node is: %d\n", common->val);  
    85.     else  
    86.         printf("There is no common node\n");  
    87.   
    88.     getchar();  
    89.     return 0;  
    90. }  
Goluck98
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
射频理论基础（关于宽带匹配）（每小节有相关例题和解答以及相关的matlab算法代码）.zip
08-25
射频(RF)理论基础是电子工程领域中的一个重要分支，主要研究的是在宽频率范围内电磁信号的传输、处理和控制。宽带匹配则是其中的关键技术，它涉及到如何使射频系统中的不同组件，如天线、放大器、滤波器等，在广泛的...
十五个经典算法详解
05-19
十五个经典算法详解，多年困惑没搞懂的算法都在此了。
15道使用频率极高的基础算法题
lyg468088的专栏
06-13 1227
1、合并排序，将两个已经排序的数组合并成一个数组，其中一个数组能容下两个数组的所有元素;           2、合并两个已经排序的单链表;           3、倒序打印一个单链表;         4、给定一个单链表的头指针和一个指定节点的指针，在O(1)时间删除该节点;           5、找到链表倒数第K个节点;           6、反转单链表;      
十五个经典算法集锦
11-15 2454
一、A*搜索算法一（续）、A*，Dijkstra，BFS算法性能比较及A*算法的应用二、Dijkstra 算法初探二（续）、彻底理解Dijkstra算法二（再续）、Dijkstra 算法+fibonacci堆的逐步c实现二（三续）、Dijkstra 算法+Heap堆的完整c实现源码三、dynamic programming四、BFS和DFS优先搜索算法五、红黑树算法的实现与剖析五（续）、教你透彻了
合成孔径雷达成像算法与实现（附光盘数据和仿真代码）
04-26
在"合成孔径雷达成像算法与实现（附光盘数据和仿真代码）"这本书中，作者深入探讨了SAR成像的基本原理和关键算法。书中可能涵盖了以下主要知识点： 1. **SAR基本原理**：介绍SAR的工作模式，包括侧视雷达（Side-...
FPGA实现低通滤波器（内含完整的FPGA代码）
04-11
1. 并行处理：FPGA 的硬件并行性使得它能够同时处理多个数据样本，极大地提高了处理速度。 2. 实时性：FPGA 可以实现实时滤波，无需等待CPU介入。 3. 灵活性：FPGA 程序可以通过重配置来适应不同的滤波器规格和性能...
蓝桥杯嵌入式2019年第十届省赛真题代码
01-31
在省赛代码中，选手可能使用了结构体、指针、中断服务程序等C语言特性，以实现高效且低级的控制。 3. **实时操作系统（RTOS）**：RTOS在嵌入式开发中扮演着重要角色，如FreeRTOS、μC/OS等。分析代码，我们可以学习...
见过的基础算法题
fox_bert的博客
06-03 241
1、求质数 质数的定义： 对于大于1的数，如果除了1和它本身，它不能再被其它正整数整除，那么我们说它是一个质数。 判断一个数是否为质数（素数）方法： 如果是偶数，直接返回；然后从3开始，到小于本值的数，都除不尽则为质数。 public class Main { public static void main(String[] args) { for(int i=0;i<=100...
40个java算法题，都弄会了，java基础就算入门了，很经典
06-13
【程序1】 题目：判断101-200之间有多少个素数，并输出所有素数。 1.程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除， 则表明此数不是素数，反之是素数。 public class exp2{ public static void main(String args[]){ int i=0; math mymath = new math(); for(i=2;i<=200;i++) if(mymath.iszhishu(i)==true) System.out.println(i); } } class math { public int f(int x) { if(x==1 || x==2) return 1; else return f(x-1)+f(x-2); } public boolean iszhishu(int x) { for(int i=2;i<=x/2;i++) if (x % 2==0 ) return false; return true; } } 【程序2】 题目：打印出所有的 "水仙花数 "，所谓 "水仙花数 "是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个 "水仙花数 "，因为153=1的三次方＋5的三次方＋3的三次方。 1.程序分析：利用for循环控制100-999个数，每个数分解出个位，十位，百位。 public class exp2{ public static void main(String args[]){ int i=0; math mymath = new math(); for(i=100;i<=999;i++) if(mymath.shuixianhua(i)==true) System.out.println(i); } } class math { public int f(int x) { if(x==1 || x==2) return 1; else return f(x-1)+f(x-2); } public boolean iszhishu(int x) { for(int i=2;i<=x/2;i++) if (x % 2==0 ) return false; return true; } public boolean shuixianhua(int x) { int i=0,j=0,k=0; i=x / 100; j=(x % 100) /10; k=x % 10; if(x==i*i*i+j*j*j+k*k*k) return true; else return false; } }
测量频率显示
12-02
单片机开发板上成功的，52写的测量频率并显示的程序的程序，里面也会有写protus仿真
那些算频率的算法，现在都怎么样了？
weixin_33721344的博客
08-02 289
面试 19：输出数组中出现次数超过一半的数字（剑指 Offer 26 题） 上一篇推文给大家留下的习题来自于《剑指 Offer》第 29 题：数组中超过一半的数字，不知道各位去思考了么？ 面试题：数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字并输出。比如 {1,2,3,2,2,2,1} 中 2 的次数是 4，数组长度为 7，所以输出 2。要求不能修改输入的数组。 准备测试用例 这...
算法题练习——JS Node+python题解NC15 求二叉树的层序遍历
最新发布
weixin_53919192的博客
08-30 298
本文向大家用JS Node+python题解NC15 求二叉树的层序遍历，希望对你有帮助~~
几种编程题高难度常用算法总结
jacksonary的博客
08-29 4982
笔试的编程题总是很头疼，怕的有思路编不出来，作为一个半路出家健忘者，不得不记录一些见得比较多的算法，相信对以后笔试的编程题会有大大的帮助，话不多说，开始。 1.穷举法
高级数据结构与算法 编程题（待续）
孤傲小二~阿沐的博客
07-20 252
问题1：（动态规划） https://www.nowcoder.com/profile/906397853/codeBookDetail?submissionId=51239757 小易来到了一条石板路前，每块石板上从1挨着编号为：1、2、3… 这条石板路要根据特殊的规则才能前进：对于小易当前所在的编号为K的 石板，小易单次只能往前跳K的一个约数(不含1和K)步，即跳到K+X(X为K的一个非1和本...
以整数元素构成的list中的数字组成最小整数
老齐教室
06-10 478
把一个int型数组中的数字拼成一个串，这个串代表的数字最小。用python解决此问题的方法。
面试题1
weixin_42639771的博客
06-12 144
计算机网络重要知识点总结 面试必备 https://blog.csdn.net/u011225629/article/details/45224279 C语言面试专用题库 1. C/C++笔试面试经典题目一 https://wenku.baidu.com/view/51dc37cd77eeaeaad1f34693daef5ef7ba0d1211.html 100条经典C语言笔试题目 面试技巧、简历...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值