程序面试题——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 (1)
    {
        scanf("%d", &temp);
        if (temp == -1)
        {
            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("
");
}
 
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
");
 
}

时间复杂度：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, 0, m-1);
    ReverseString(s, m+1, n-1);
    ReverseString(s, 0, n-1);
}

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

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

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

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

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

#include <stdio.h>
 
/* 判断一个数组中是否有重复元素，若有，返回位置及元素 */
void hasDup(int arr[], int n)
{
    int i, j;
    for(i=0; i<n-1; i++)
    {    for(j=i+1; j<n; j++)
            if(arr[j] == arr[i])
            {
                printf("数组中第%d个位置存在重复元素:%d
",j,arr[i]);            
                break;    
            }
            continue;
    }
}
 
/* 主函数 */
int main()
{
    int arr[] = {12, 6, 22, 9, 16, 50, 18, 9, 6, 9};
    int n = 10;

    hasDup(arr, n);     
 
    return 0; 
}

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

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

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

 参考：最长递增子序列的三种算法  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[1000];//存放升序排列的一列数字
int b[1];//存放要找的数字
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
", a[mn]);
            printf("%d
", a[mn+1]);
        }
        else//比最大的还大
        {
            printf("%d
", a[mx-1]);
            printf("%d
", a[mx]);
        }
    }
    else//位于最小的数字和最大的数字之间
    {
        //根据mid来分，比mid大还是比mid小，还是和mid相等
        if (a[mn]<b[j] && b[j]<a[mid])//比mid小
        {
            if (mid - mn != 1)
            {
                mx = mid - 1;//将mx替换为mid
                mid = (mn + mx) / 2;//重新计算mid下标
                finder(mx, mn, mid, j);
            }
            else
            {
                if (a[mid] - b[j]>b[j] - a[mn])//比较距离
                    printf("%d
", a[mn]);
                else if (a[mid] - b[j]<b[j] - a[mn])
                    printf("%d
", a[mid]);
                else
                    printf("%d %d
", a[mn], a[mid]);
            }
 
        }
        else if (a[mid]<b[j] && b[j]<a[mx])//比mid大
        {
 
            if (mx - mid != 1)
            {
                mn = mid;//重新计算mn
                mid = (mn + mx) / 2;//重新计算mid下标
                finder(mx, mn, mid, j);
            }
            else
            {
                if (b[j] - a[mid]>a[mx] - b[j])
                    printf("%d
", a[mx]);
                else if (b[j] - a[mid]<a[mx] - b[j])
                    printf("%d
", a[mid]);
                else
                    printf("%d %d
", a[mid], a[mx]);
            }
        }
        else//和mid相等
        {
            printf("%d
", b[j]);
            if((b[j]-a[mid-1]) >= (a[mid+1]-b[j]))
                printf("%d
", a[mid+1]);
            else
                printf("%d
", a[mid-1]);
        }
    }
    return 0;
}
int main()
{
    int j = 0;//用作函数循环的
    int n;//输入非降序序列的长度
    printf("请输入非降序序列的长度：");    
    scanf("%d", &n);
    printf("请输入非降序序列：");    
    for (int i = 0; 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[0]);
    int mx = n - 1, mn = 0;
    int mid = (mx + mn) / 2;
//    for (j = 0; j<m; j++)//循环调用函数，把b[j]中存储的所有要找的数字找完
        finder(mx, mn, mid, 0);
    //system("pause");
    return 0;
 
}