把数组排成最小的数

题目描述

输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。

 

一、初步想法

初步想法就是快速排序，不过需要改less比较函数的快速排序，

比较算法如下：

两个数：1235、12

首先将12扩大到同1235同位数，即 先：12 * 10 + 12 % 10 ，（12 * 10 + 12 % 10） * 10  + 12 % 10 = 1222

再将扩大后的数1222与 1235比较大小，小的排序在前面，大的排序在后面

less实现如下：

        bool less(int a, int b, bool l = false)
        {
            // 判断位数
            int a1 = a;
            int b1 = b;

            while (a > 0 || b > 0)
            {
                a /= 10;
                b /= 10;
                if (a == 0 && b != 0) 
                {
                    a1 = a1 * 10 + a1 % 10;
                }
                if (b == 0 && a != 0)
                {
                    b1 = b1 * 10 + b1 % 10;
                }
            }

            if (l)
            {   
                return a1 < b1;
            }
            return a1 >= b1;
        }

整体实现如下：

#pragma once
#include <string>
#include <sstream>
#include <vector>
using namespace std;

namespace min_sort_number
{
    class Solution {
    public:
        std::string PrintMinNumber(vector<int> numbers) 
        {
            if (numbers.size() == 0)
            {
                return "";
            }

            quick_sort(numbers, 0, numbers.size() - 1);
            return print(numbers);
        }

        void quick_sort(vector<int> &numbers, int left, int right)
        {
            if (left < right)
            {
                int i = left, j = right, x = numbers[left];
                while (i < j)
                {
                    while (i < j && less(numbers[j], x)) // 从右向左找第一个小于x的数
                        j--;

                    if (i < j)
                        numbers[i++] = numbers[j];

                    while (i < j &&  less(numbers[i], x, true)) // 从左向右找第一个大于等于x的数
                        i++;

                    if (i < j)
                        numbers[j--] = numbers[i];
                }
                numbers[i] = x;
                quick_sort(numbers, left, i - 1); // 递归调用
                quick_sort(numbers, i + 1, right);
            }
        }


        bool less(int a, int b, bool l = false)
        {
            // 判断位数
            int a1 = a;
            int b1 = b;

            while (a > 0 || b > 0)
            {
                a /= 10;
                b /= 10;
                if (a == 0 && b != 0) 
                {
                    a1 = a1 * 10 + a1 % 10;
                }
                if (b == 0 && a != 0)
                {
                    b1 = b1 * 10 + b1 % 10;
                }
            }

            if (l)
            {   
                return a1 < b1;
            }
            return a1 >= b1;
        }

        string  print(vector<int> &number)
        {
            std::stringstream ss;
            for (int i = 0; i < number.size(); i++)
            {
                ss << number[i];
            }

            string ret;
            ss >> ret;
            return ret;
        }
    };
}

test.cpp

#pragma once
#include "min_sort_number.h"

namespace min_sort_number
{
    void start_test()
    {
        Solution s;
        vector<int> v;
        v.push_back(3);
        v.push_back(32);
        v.push_back(321);

        //v.push_back(3);
        //v.push_back(5);
        //v.push_back(1);
        //v.push_back(4);
        //v.push_back(2);


        string c = s.PrintMinNumber(v);
        bool t = s.less(323, 3, true);
    }
}

二、其他解法

      还有就转换为字符串 ，直接字符串相加然后换序将 compare()比较大小，确定先后顺序。