#include<iostream>
 #include<cstring>
 using namespace std;
 
int q_max(int x,int y,int z,int h){
     x=x>y?x:y;
     x=x>z?x:z;
     x=x>h?x:h;
     return x;
 }
 
int main(){
     //找出4个数中的最大值 
     int x,y,z,h;
     cin >>x>>y>>z>>h;
     int M_max=q_max(x,y,z,h);
     cout <<M_max;
     
     return 0;
 }

首先我们使用常规做法，循环交换完成。
 
lst = [1, 3, 5, 8]

for i in range(0, len(lst)):
    lst[i], lst[0] = lst[0], lst[i]
    for j in range(1, len(lst)):
        lst[j], lst[1] = lst[1], lst[j]
        for h in range(2, len(lst)):
            lst[h], lst[2] = lst[2], lst[h]         
            print(lst)
            lst[h], lst[2] = lst[2], lst[h]    
        lst[j], lst[1] = lst[1], lst[j]
    lst[i], lst[0] = lst[0], lst[i]

 
如果列表较长，元素较多，以上常规方法实现起来就比较吃力了，以下我们采用递归方式实现。
 
def permutations(position):
    if position == len(lst) - 1:
        print(lst)
    else:
        for index in range(position, len(lst)):
            lst[index], lst[position] = lst[position], lst[index]
            permutations(position+1)
            lst[index], lst[position] = lst[position], lst[index]
permutations(0)  

package com.offcn.字节流练习;
 
 
 public class Test2 {
 
 
 public static void main(String[] args) {
 
 
 int hig = 0;
 
 
 int low = 0;
 
 
 for (int i = 1000; i < 9999; i++) {
 
 
 int q = i % 10;
 
 
 int w = i / 10 % 10;
 
 
 int e = i / 100 % 10;
 
 
 int r = i / 1000;
 
 
 int[] four = { q, w, e, r };
  

 
 

 
 
//排序从小到大
 for (int j = 0; j < four.length; j++) {
 
 
 for (int k = 0; k < four.length - 1; k++) {
 if (four[k] > four[k + 1]) {
 int temp = four[k];
 four[k] = four[k + 1];
 four[k + 1] = temp;
 }
 }
 
 
 }
 
 //如果第一位有0；第二位有零；第三位有零，则相互调换
 for (int j = 1; j < four.length; j++) {
 
 
 if (four[0] == 0) {
 int temp = four[j];
 four[j] = four[0];
 four[0] = temp;
 } else {
 break;
 }
 
 
  
}
 
//取出最小值
 
String min = "";
 
 
 for (int j : four) {
 
 
 min += String.valueOf(j);
 }
  
low = Integer.parseInt(min);
 

 
 

 
 
//以下是找出最大值
 
 for (int j = 0; j < four.length; j++) {
 
 
 for (int k = 0; k < four.length - 1; k++) {
 
 
 if (four[k] < four[k + 1]) {
 
 
 int temp = four[k];
 
 
 four[k] = four[k + 1];
 
 
 four[k + 1] = temp;
 
 
 }
 
 
 }
 
 
 }
 String max = "";
 
 
 for (int j : four) {
 
 
 max += String.valueOf(j);
 }
 
 
 hig = Integer.parseInt(max);
 if (i == hig - low) {
 System.out.println(i);
 }
 
 
 }
 
 
 }
 
 
 }

根据《算法的乐趣》简单总结一下：
 
中文数字的特点
 
中文数字直接“数字+权位”的方式组成数字，比如阿拉伯数字100，中文表示为一百，其中“一”为数字，“百”为权位。常用的数字权位有“十”，“百”，“千”，“万”，“亿”等
 
 
中文数字的权位和小节
 中文数字的特点之一就是每个计数数字都跟着一个权位，这个权位就是数字的量值，相当于阿拉伯数字中的数位。最低位（个位）没有权位，也可以理解为权位为空
 中文数字的另一个特点是以“万”为小节（欧美习惯以“千”为小节），每一个小节都有一个节权位，万以下的没有节权位（或节权位为空），万以上的就是万，再大的就是“亿”，每个小节内部都以“十百千”为权位的独立计数。“十百千”这几个权位是不能连续出现的，如二十百，一千千，但万和亿作为节权位却可以和其他权位一起使用，如二十亿等
 
 
中文数字的零
 中文对零的使用总结有以下三条：
 规则1：以10000为小节，小节的结尾即使是0，也不使用“零”。
 规则2：小节内两个非0数字之间要使用“零”。
 规则3：当小节的“千”为是0是，若本小节的前一小节无其他数字，则不用“零”，否则用“零”。
 
 
阿拉伯数字转中文数字
 
第一步是以“万”为单位分节，并确定节权位。第二步是对每小节内的数字确定权位，并按照上面的三条规则处理“零”的问题
 
转换算法设计
 
#include <iostream>
#include <cstring>
#include <cstdio>

using namespace std;
const int CHN_NUM_CHAR_COUNT = 10;

//单个数字对应的中文汉字
const char *chnNumChar[CHN_NUM_CHAR_COUNT] = {"零", "一", "二", "三", "四", "五", "六", "七", "八", "九"};
//小节位，对32位正数表达的最大整数来说，最大节权万亿就够了
const char *chnUnitSetion[] = {"", "万", "亿", "万亿"};
//每个小节里面的独立计数
const char *chnUnitChar[] = {"", "十", "百", "千"};


void NumberToChinese(unsigned int num, string &chnStr);
//每个小节内单独处理
void SectionToChinese(unsigned int section, string &chnStr);

int main() {
    unsigned int num;
    string str="请输入";
    cout<<str<<endl;
    while (cin >> num && (num != 0)) {
        string chnStr="";
        NumberToChinese(num, chnStr);
        cout<<chnStr<<endl;
    }
    return 0;
}

void NumberToChinese(unsigned int num, string& chnStr) {
    int unitPos = 0;   //小节的位置
    bool needZero = false;  //初始默认规则3不需要0
    while (num > 0) {
        string strIns="";
        unsigned int section = num % 10000;
        if (needZero) {  //满足规则3需要添零，根据后面的语句是否修改了needZero来检测是否添加0
            chnStr.insert(0, chnNumChar[0]);
        }
        SectionToChinese(section, strIns);
//        检测当前section的的是否是0，如果是0的话，则添加空字符串的节权位，否则添加其他的
        strIns += (section != 0) ? chnUnitSetion[unitPos] : chnUnitSetion[0];
        chnStr.insert(0, strIns);
//        当满足小节内的值小于1000且值大于0的时候表示当前小节的千位是一个0，如果前面一小节还有值的时候则添0
        needZero = (section < 1000) && (section > 0);
        num /= 10000;
        unitPos++;
    }
}

void SectionToChinese(unsigned int section, string &chnStr) {
    string strIns="";
//    当前小节内的当前个数的独立计数的权位
    int unitPos = 0;
//    先设置zero为true，为了测试规则二，两个相连的0只留一个
    bool zero = true;
    while (section > 0) {
        int v = section % 10;
        if (v == 0) {
//            当不是两个0相连的时候或者 添加0在数字中
            if (!zero) {
//                当出现一个0的时候就设置zero为true，当下一个还是0的时候就不添加0了
                zero = true;
                chnStr.insert(0, chnNumChar[v]);
            }
        } else {
//            当出现一个不是0的数字的时候就设置当前的zero标志为false表示下次遇到0的时候还是要添加
            zero = false;
            strIns = chnNumChar[v];
            strIns += chnUnitChar[unitPos];
//            将这个strIns插入到总的字符串的开始的位置
            chnStr.insert(0, strIns);
        }
//        权位增加
        unitPos++;
//        小节值除以10
        section /= 10;
    }
}
 
运行测试：