BM55 没有重复项数字的全排列

using System;
using System.Collections.Generic;


class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * @param numbers int整型一维数组 
     * @return int整型
     */
    public int MoreThanHalfNum_Solution (List<int> numbers) {
        // write code here
        if(numbers == null || numbers.Count == 0)
        {
            return 0;
        }
        int temp = numbers[0];
        int count = 1;

        for(int i = 1; i < numbers.Count; i++)
        {
            if(temp == numbers[i])
                count++;
            else
            {
                count--;
                if(count == 0)
                {
                    temp = numbers[i];
                    count++;
                }
            }
        }
        int num = 0;
        for(int i = 0; i < numbers.Count; i++)
        {
            if(temp == numbers[i])
                num++;
        }
        return (num > numbers.Count / 2) ? temp : 0;
    }
}

解决这个问题的关键是全排列的递归回溯算法。以下是对给定列表 [1,2,3] 进行全排列的详细解说：

1. 定义递归函数 permute，该函数接受一个一维整型数组 num，并返回一个二维整型数组 List<List<int>>。在函数内部创建一个 List<List<int>> 类型的变量 res，用于存储最终的结果。

2. 在 permute 函数内部调用一个辅助函数 permute，该函数接受两个参数：start 和 num。

3. 在 permute 函数内部判断如果 start 等于 num 列表的长度，则表示已经遍历完整个列表，将当前列表加入到结果 res 中。

4. 如果 start 不等于 num 列表的长度，则进入循环遍历，从 start 开始遍历到 num 列表的长度。在遍历过程中，进行以下操作：

   a. 调用 swap 函数，将 num 列表中的第 start 个元素与第 i 个元素进行交换。

   b. 调用 permute 函数，将 start+1 和 num 作为参数继续递归调用。

   c. 再次调用 swap 函数，将 num 列表中的第 start 个元素与第 i 个元素进行交换，恢复原始状态。

5. 定义一个 swap 函数，该函数接受一个列表 list 和两个索引 i 和 j，用于交换列表中的两个元素位置。

6. 最后返回结果 res。

对于输入的列表 [1,2,3]，该算法的执行过程如下：

1. permute([1,2,3]) 调用 permute(0,[1,2,3])。

2. 在 permute(0,[1,2,3]) 中，start 等于 0，不等于列表的长度，进入循环遍历。

   a. 第一次循环，i 等于 0，调用 swap([1,2,3],0,0)，得到 [1,2,3]。调用 permute(1,[1,2,3])。

   b. 在 permute(1,[1,2,3]) 中，start 等于 1，不等于列表的长度，进入循环遍历。

      - 第一次循环，i 等于 1，调用 swap([1,2,3],1,1)，得到 [1,2,3]。调用 permute(2,[1,2,3])。

      - 在 permute(2,[1,2,3]) 中，start 等于 2，等于列表的长度，将 [1,2,3] 加入结果 res。

      - 再次调用 swap([1,2,3],1,1)，恢复原始状态。

      - 第二次循环，i 等于 2，调用 swap([1,2,3],1,2)，得到 [1,3,2]。调用 permute(2,[1,3,2])。

      - 在 permute(2,[1,3,2]) 中，start 等于 2，等于列表的长度，将 [1,3,2] 加入结果 res。

      - 再次调用 swap([1,3,2],1,2)，恢复原始状态。

   c. 再次调用 swap([1,2,3],0,0)，恢复原始状态。

   d. 第二次循环，i 等于 1，调用 swap([1,2,3],0,1)，得到 [2,1,3]。调用 permute(1,[2,1,3])。

   e. 在 permute(1,[2,1,3]) 中，start 等于 1，不等于列表的长度，进入循环遍历。

      - 第一次循环，i 等于 1，调用 swap([2,1,3],1,1)，得到 [2,1,3]。调用 permute(2,[2,1,3])。

      - 在 permute(2,[2,1,3]) 中，start 等于 2，等于列表的长度，将 [2,1,3] 加入结果 res。

      - 再次调用 swap([2,1,3],1,1)，恢复原始状态。

      - 第二次循环，i 等于 2，调用 swap([2,1,3],1,2)，得到 [2,3,1]。调用 permute(2,[2,3,1])。

      - 在 permute(2,[2,3,1]) 中，start 等于 2，等于列表的长度，将 [2,3,1] 加入结果 res。

      - 再次调用 swap([2,3,1],1,2)，恢复原始状态。

   f. 再次调用 swap([1,2,3],0,1)，恢复原始状态。

   g. 第三次循环，i 等于 2，调用 swap([1,2,3],0,2)，得到 [3,2,1]。调用 permute(1,[3,2,1])。

   h. 在 permute(1,[3,2,1]) 中，start 等于 1，不等于列表的长度，进入循环遍历。

      - 第一次循环，i 等于 1，调用 swap([3,2,1],1,1)，得到 [3,2,1]。调用 permute(2,[3,2,1])。

      - 在 permute(2,[3,2,1]) 中，start 等于 2，等于列表的长度，将 [3,2,1] 加入结果 res。

      - 再次调用 swap([3,2,1],1,1)，恢复原始状态。

      - 第二次循环，i 等于 2，调用 swap([3,2,1],1,2)，得到 [3,1,2]。调用 permute(2,[3,1,2])。

      - 在 permute(2,[3,1,2]) 中，start 等于 2，等于列表的长度，将 [3,1,2] 加入结果 res。

      - 再次调用 swap([3,1,2],1,2)，恢复原始状态。

   i. 再次调用 swap([1,2,3],0,2)，恢复原始状态。

7. 最终结果 res 是一个二维整型数组，包含了 [1,2,3]、[1,3,2]、[2,1,3]、[2,3,1]、[3,1,2]、[3,2,1] 六种排列方式。返回结果 res。

所以，返回的结果为[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]。