【欢聚时代】真题-归并排序

【欢聚时代】真题-归并排序

题目描述

请编程实现一个整型数组的归并排序。本题会人工判断,请严格按照题目描述完成

输入描述

一个无序的整型数组,输入格式见输入样例

输出描述

一个有序的整型数组,输出格式见输出样例

示例一

输入

[3, 1, 4, 5, 17, 2, 12]

输出

[1, 2, 3, 4, 5, 12, 17]

说明

参考解题 C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <assert.h>

#define N 1000000 // 1百万

// ==================== Function Declaration ====================
// C99 标准库高仿函数
int str_len(const char * s);
void mergeSort(int* nums, int* tmpArr, int l, int r);
void merge(int* nums, int* tmpArr, int l, int m, int r);
void printNumbers(int* nums, const int numsSize);
// ==================== Function Declaration ====================

int main(const int argc, const char** argv) {
  int nums[N], numsSize = 0;
  
  char temp[10 * N]; // 设有一百万个整数,每个整数占10位
  gets(temp);
  
  char* line = malloc(10 * N * sizeof(char));
  strncat(line, temp + 1, str_len(temp) - 2);
  
  char* tok = strtok(line, ",");
  while (tok) {
    *(nums + numsSize++) = atoi(tok);
    tok = strtok(NULL, ",");
  }
  // Divide and Conquer algorithm 的经典应用 ---- merge_sort
  int tmpArr[N];
  mergeSort(nums, tmpArr, 0, numsSize - 1);
  return printNumbers(nums, numsSize), 0;
}

int str_len(const char * s) {
  assert(s != NULL);
  // corner case  
  if (*s == '\0') return 0;
  
  const char * pc = s;
  while (*++pc != '\0');
  return pc - s;
}

void mergeSort(int* nums, int* tmpArr, int l, int r) {
  // recursion exit condition (空集或只有一个元素就认为是有序的)
  if (l >= r) return;
  
  int m = (l + r) >> 1;
  mergeSort(nums, tmpArr, l, m);
  mergeSort(nums, tmpArr, m + 1, r);
  merge(nums, tmpArr, l, m, r);
}

void merge(int* nums, int* tmpArr, int l, int m, int r) {
  int i = l, j = m + 1, k = l;
  while (k <= r)
    if (i > m)
      *(tmpArr + k++) = *(nums + j++);
    else if (j > r)
      *(tmpArr + k++) = *(nums + i++);
    else
      *(tmpArr + k++) = *(nums + i) < *(nums + j) ? *(nums + i++) : *(nums + j++);
      
  memcpy(nums + l, tmpArr + l, (r - l + 1) * sizeof(int));
}

void printNumbers(int* nums, const int numsSize) {
  int i;
  putchar('[');
  for (i = 0; i < numsSize; ++i) {
    printf("%d", *(nums + i));
    if (i < numsSize - 1) printf(", ");
  }
  printf("]\n");
}

参考解题 C++

#include <iostream>
#include <vector>

using namespace std;

void merge_sort_recursive(vector<int> &v, vector<int> &tmp, int start, int end);

void merge_sort_recursive(vector<int> &v, vector<int> &tmp, int start, int end) {
	if (start >= end) return;
    int mid = start + (end - start) / 2;
    int start1 = start, end1 = mid;
    int start2 = mid + 1, end2 = end;
    merge_sort_recursive(v, tmp, start1, end1);
    merge_sort_recursive(v, tmp, start2, end2);
    int index = start;
    while (start1 <= end1 && start2 <= end2) {
    	if (v[start1] > v[start2]) {
            tmp[index++] = v[start2++];
        } else {
            tmp[index++] = v[start1++];
        }
    }
    
    while (start1 <= end1) {
        tmp[index++] = v[start1++];
    }
    
    while (start2 <= end2) {
        tmp[index++] = v[start2++];
    }
    
    for (int i = start; i <= end; i++) {
        v[i] = tmp[i];
    }
}

void merge_sort(vector<int> &v) {
    vector<int> tmp(v.size(), 0);
    merge_sort_recursive(v, tmp, 0, v.size() - 1);
}

int main() {
    char c;
    cin >> c;
    
    int j;
    vector<int> v;
    while (cin >> j >> c) {
        v.push_back(j);
    }
    int len = v.size();
    merge_sort(v);
    
    cout << "[";
    for (int i = 0; i < v.size(); i++) {
        if (i == v.size() - 1)
            cout << v[i];
        else 
        	cout << v[i] << ", ";
    }
    cout << "]" << endl;
    return 0;
}

参考解题 Java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringJoiner;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String s = br.readLine();
        s = s.replace("[","");
        s = s.replace("]","");
        String[] ss = s.split(", ");
        int[] arr = new int[ss.length];
        for (int i = 0; i < ss.length; i++) {
            arr[i] = Integer.parseInt(ss[i]);
        }
        sort(arr);
        StringJoiner sj = new StringJoiner(", ");
        System.out.println(sj.add(Arrays.toString(arr)));
    }

    public static void sort(int[] arr) {
        int[] temp = new int[arr.length];//在排序前,先建好一个长度等于原数组长度的临时数组,避免递归中频繁开辟空间
        sort(arr, 0, arr.length - 1, temp);
    }

    private static void sort(int[] arr, int left, int right, int[] temp) {
        if (left < right) {
            int mid = (left + right) / 2;
            sort(arr, left, mid, temp);//左边归并排序,使得左子序列有序
            sort(arr, mid + 1, right, temp);//右边归并排序,使得右子序列有序
            merge(arr, left, mid, right, temp);//将两个有序子数组合并操作
        }
    }

    private static void merge(int[] arr, int left, int mid, int right, int[] temp) {
        int i = left;//左序列指针
        int j = mid + 1;//右序列指针
        int t = 0;//临时数组指针
        while (i <= mid && j <= right) {
            if (arr[i] <= arr[j]) {
                temp[t++] = arr[i++];
            } else {
                temp[t++] = arr[j++];
            }
        }
        while (i <= mid) {//将左边剩余元素填充进temp中
            temp[t++] = arr[i++];
        }
        while (j <= right) {//将右序列剩余元素填充进temp中
            temp[t++] = arr[j++];
        }
        t = 0;
        //将temp中的元素全部拷贝到原数组中
        while (left <= right) {
            arr[left++] = temp[t++];
        }
    }
}

参考解题 Python

inList=input()
if isinstance(inList, list):
    print(sorted(inList))
else:
    print(sorted(eval(inList)))
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

AmosCloud2013

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值