程序面试题——C实现

平台：win10 x64 +VC6.0

2019/5/22

1.合并三个有序的链表

链表节点定义
struct node
{
    int val;
    struct node* next;
};

struct node* merge_3 (形参由你定义)
{
    //这部分是实现
}

当输入的有序链表是多个的时候，请给出合并算法，并假设链表个数为m，平均长度为n，请分析时间复杂度

思路：参看 https://blog.csdn.net/wwxy1995/article/details/82120194

 #include <stdio.h>
 #include <stdlib.h>
 #define MAXSIZE 20

 typedef int ElemType;
 typedef struct Node
 {
     ElemType data;
     struct Node *next;

 }Node;

 typedef struct Node *LinkList;

 // 初始化链表
 bool InitList(LinkList *L) // 二级指针
 {
     *L = (LinkList)malloc(sizeof(Node));  //产生头结点，并使L指向此头节点
     if (!(*L))   // 存储分配失败
         return false;
     (*L)->next = NULL;
     return true;
 }
 void CreateFromTail(LinkList L)
 {
     Node *r, *s;
     int temp;
     r = L;  // r指向链表的当前表尾，其初值指向头节点
     while ()
     {
         scanf("%d", &temp);
         if (temp == -)
         {
             r->next = NULL;
             break;
         }
         s = (Node*)malloc(sizeof(Node));   // 建立新结点s
         s->data = temp;
         r->next = s;
         r = s;

     }
 }

 // 遍历链表
 void PrintList(LinkList L)
 {
     bool flag = true;
     Node *p;
     p = L->next;
     while (p)
     {
         if (flag)
         {
             printf("%d", p->data);
             flag = false;
         }
         else
             printf(" %d", p->data);
         p = p->next;
     }
     printf("\n");
 }

 LinkList MergeLinkList(LinkList L1, LinkList L2)
 {
     LinkList L3;
     InitList(&L3);

     Node *p, *q, *r, *s;
     p = L1->next;
     q = L2->next;
     r = L3;
     while (p&&q)
     {
         if (p->data < q->data)
         {
             s = (Node*)malloc(sizeof(Node));
             s->data = p->data;
             s->next = NULL;
             r->next = s;
             r = s;
             p = p->next;
         }
         else
         {
             s = (Node*)malloc(sizeof(Node));
             s->data = q->data;
             s->next = NULL;
             r->next = s;
             r = s;
             q = q->next;
         }
     }

     if (p == NULL)
     {
         r->next = q;
     }
     if (q == NULL)
     {
         r->next = p;
     }
     return L3;
 }

 int main()
 {
     LinkList L1,L2,L3,L4;
     InitList(&L1);  // 指针的地址
     InitList(&L2);  // 指针的地址
     InitList(&L3);  // 指针的地址
     InitList(&L4);  // 指针的地址
     CreateFromTail(L1);
     PrintList(L1);
     CreateFromTail(L2);
     PrintList(L2);
     CreateFromTail(L3);
     PrintList(L3);
     L4 = MergeLinkList(L1, L2);
     PrintList(L4);
     L4 = MergeLinkList(L3, L4);
     PrintList(L4);
     if (L4->next)
         PrintList(L4);
     else
         printf("NULL\n");

 }

合并三个有序的链表

时间复杂度：O(max(length(L1),length(L2),length(L1)+length(L2),length(L3)))

2019/5/23

1.“ hello world”转为“ world hello”

思路：参看 C语言字符串指针（指向字符串的指针）详解：http://c.biancheng.net/view/2012.html

 #include <stdio.h>
 #include <string.h>

 void ReverseString(char* s, int from, int to)
 {
     while(from < to)
     {
         char t = s[from];
         s[from++] = s[to];
         s[to--] = t;
     }
 }

 void LeftRotateString(char* s, int n, int m)
 {
     m %=n;
     ReverseString(s, , m-);
     ReverseString(s, m+, n-);
     ReverseString(s, , n-);
 }

 int main(void)
 {
     int n = , m = , i;
     char s[] = "hello world";
     printf("转换前的字符串为:%s\n", s);
     n = strlen(s);
     for(i = ; i < n; i++)
         if(s[i] == ' ')
             m = i;

     printf("n=%d,m=%d\n", n,m);
     LeftRotateString(s, n, m);
     printf("转换后的字符串为:%s\n", s);
     return ;
 }

字符串反转

时间复杂度O(n)，空间复杂度O(1)

2.无序数组，找出全部重复元素

思路：参看《编程之法》1.1字符串的旋转 解法二：三步反转

 #include <stdio.h>

 /* 判断一个数组中是否有重复元素，若有，返回位置及元素 */
 void hasDup(int arr[], int n)
 {
     int i, j;
     for(i=; i<n-; i++)
     {    for(j=i+; j<n; j++)
             if(arr[j] == arr[i])
             {
                 printf("数组中第%d个位置存在重复元素:%d\n",j,arr[i]);
                 break;
             }
             continue;
     }
 }

 /* 主函数 */
 int main()
 {
     int arr[] = {, , , , , , , , , };
     int n = ;

     hasDup(arr, n);     

     return ;
 }

查找无序数组重复元素及位置

3.给定数组arr，返回arr的最长递增子序列

思路：参看左程云 《程序员代码面试指南》  https://blog.csdn.net/hahayikeshu/article/details/85549681

 #include<stdio.h>
 #include<stdlib.h>
 #include<string.h>
 int main()
 {
     int n=,k[],h[],g=,j,t;
     char c;
     char m[];
     printf("请输入子序列：");
     memset(k,,sizeof(k)); //把数组k元素全置为零
     while(n--)
     {
         int i=,l=;
         getchar();//滤掉回车
         while((c=getchar())!='\n')
         {
             m[i++]=c;//把输入的元素逐个存入数组
         }
           for(j=;j<i-;j++)
          {
              if(m[j]<m[j+])
              {
                  k[l]=k[l]+;
              }
              else
                 l++;
          }
          l++;
          if(l==)
          {
              if(k[]<k[])
              {
                 t=k[];
                 k[]=k[];
                 k[]=t;
              }
          }
           if(l>)
          {
                for(j=;j<l-;j++)
                  for(i=;i<l-j-;i++)
                      if(k[i]<k[i+])
                      {
                       t=k[i];
                       k[i]=k[i+];
                       k[i+]=t;
                      }
          }

          h[g]=k[];
          g++;
      }
     for(int i=;i<g;i++)
     {
         printf("\n");
         printf("单调递增最长子序列长度为：%d\n",h[i]+);
     }
     return ;
 } 

输入数组arr,返回最长递增子序列的长度

参考：最长递增子序列的三种算法  https://blog.csdn.net/love20165104027/article/details/79618367

4.升序数组，找出最接近定值sum的两个元素，并输出

思路：二分查找 参看 https://blog.csdn.net/GenuineMonster/article/details/88838346

问题：long long定义时，如果还用scanf()函数输入，编译器不报错，但是输入的数字完全改变。

针对这个问题，我也找到了相应的解决办法，请看这篇文章：https://blog.csdn.net/GenuineMonster/article/details/88813979

 #include<stdio.h>
 #include<stdlib.h>
 int a[];//存放升序排列的一列数字
 int b[];//存放要找的数字
 int m;//输入要查找的数的个数
 long finder(int mx, int mn, int mid, int j)//
 {//第一步区分查找的这个数是否在开区间内
     if (b[j] <= a[mn] || b[j] >= a[mx])//不在
     {
         //对内部进行细分，到底是比最小的还小，还是比最大的还大
         if (b[j] <= a[mn])  //比最小的还小
         {
             printf("%d\n", a[mn]);
             printf("%d\n", a[mn+]);
         }
         else//比最大的还大
         {
             printf("%d\n", a[mx-]);
             printf("%d\n", a[mx]);
         }
     }
     else//位于最小的数字和最大的数字之间
     {
         //根据mid来分，比mid大还是比mid小，还是和mid相等
         if (a[mn]<b[j] && b[j]<a[mid])//比mid小
         {
             if (mid - mn != )
             {
                 mx = mid - ;//将mx替换为mid
                 mid = (mn + mx) / ;//重新计算mid下标
                 finder(mx, mn, mid, j);
             }
             else
             {
                 if (a[mid] - b[j]>b[j] - a[mn])//比较距离
                     printf("%d\n", a[mn]);
                 else if (a[mid] - b[j]<b[j] - a[mn])
                     printf("%d\n", a[mid]);
                 else
                     printf("%d %d\n", a[mn], a[mid]);
             }

         }
         else if (a[mid]<b[j] && b[j]<a[mx])//比mid大
         {

             if (mx - mid != )
             {
                 mn = mid;//重新计算mn
                 mid = (mn + mx) / ;//重新计算mid下标
                 finder(mx, mn, mid, j);
             }
             else
             {
                 if (b[j] - a[mid]>a[mx] - b[j])
                     printf("%d\n", a[mx]);
                 else if (b[j] - a[mid]<a[mx] - b[j])
                     printf("%d\n", a[mid]);
                 else
                     printf("%d %d\n", a[mid], a[mx]);
             }
         }
         else//和mid相等
         {
             printf("%d\n", b[j]);
             if((b[j]-a[mid-]) >= (a[mid+]-b[j]))
                 printf("%d\n", a[mid+]);
             else
                 printf("%d\n", a[mid-]);
         }
     }
     return ;
 }
 int main()
 {
     int j = ;//用作函数循环的
     int n;//输入非降序序列的长度
     printf("请输入非降序序列的长度：");
     scanf("%d", &n);
     printf("请输入非降序序列：");
     for (int i = ; i<n; i++) //循环输入n个数字
         scanf("%d", &a[i]);
     //scanf("%d", &m);    //输入要查询的数字个数
     //for (int i = 0; i<m; i++) //循环输入要查找的数，存在b[i]中
     printf("请输入要查找的元素sum：");
         scanf("%d", &b[]);
     int mx = n - , mn = ;
     int mid = (mx + mn) / ;
 //    for (j = 0; j<m; j++)//循环调用函数，把b[j]中存储的所有要找的数字找完
         finder(mx, mn, mid, );
     //system("pause");
     return ;

 }

输入一升序数组，返回最接近给定值的两个元素