Question

我试图将基于一维数组的二维字符数组排序为键。我需要找到一个迄今为止未在密钥中使用的字符，然后根据它对其进行排序。
铁：

AEITY
EDNTB

到

TEAIY
TDENB

基于密钥：

TEAIY

第0行

我的代码与多个字符争用并提供不良结果：
的Fe：

AAABN
TEAIY
TDENB

到

ABANA
TIEYA
TNDBE

但不是我得到

ABANA
AIEYT
ENDBT

基于密钥：

阿巴纳

我想出的代码：

static char[][] SortSimiliarity(char[][] arr, char [] key, int arrRow)
    {

        Dictionary<char, int> dcKeyList = new Dictionary<char, int>();

        for (var i = 0; i < key.Length; i++)
        {
            var counterCurrentKey = 0;
            for (var j = 0; j < key.Length; j++)
            {
                if(key[i] == arr[arrRow][j]) 
                {
                    //Console.WriteLine("{0} == {1}", key[i], arr[arrRow][j]);

                    if (!dcKeyList.ContainsKey(key[i]))
                    {
                        for (var k = 0; k < key.Length; k++)
                        {
                            //Console.WriteLine("x");
                            var temp = arr[k][j];
                            arr[k][j] = arr[k][i];
                            arr[k][i] = temp;
                        }
                        dcKeyList.Add(key[i], 1);
                    }
                    else
                    {   
                        if (dcKeyList[key[i]] == counterCurrentKey)
                        {
                            Console.WriteLine("key is {0}", dcKeyList[key[i]]);
                            for (var k = 0; k < key.Length; k++)
                            {
                                //Console.WriteLine("x");

                                var temp = arr[k][j];
                                arr[k][j] = arr[k][i];
                                arr[k][i] = temp;
                            }
                            dcKeyList[key[i]]++;
                        }
                        counterCurrentKey++;
                    }
                }              
            }

        }
        return arr;
    }

我知道那个ELSE语句有问题，我在那里比较了key循环中char的当前计数。谢谢你的想法。

Answer 1

我的问题很简单。我尝试基于数组键对2d数组进行排序，但我也将相同的结果保存到相同的2d数组中，而不保留跟踪更改。这可以通过指针逻辑或新数组来解决，您只需复制已排序的结果而不更改基本2D数组。

 static char[][] SortSimiliarity(char[][] arr, char[] key, int arrRow)
            {
            // init dict

            Dictionary<char, int> dict = new Dictionary<char, int>();

            // init new matrix
            char[][] tempArray = new char[5][];
            for(var i = 0; i < 5; i++)
            {
                tempArray[i] = new char[5];
            }

            // copy new sorted keys
            for (var i = 0; i < key.Length; i++)
            {
                for (var j = 0; j < key.Length; j++)
                {
                    if (key[i] == arr[arrRow][j])
                    {
                        if (!dict.ContainsKey(key[i]))
                        {
                            dict.Add(key[i], j);
                            for(var k = 0; k < key.Length; k++)
                            {
                                tempArray[k][i] = arr[k][j];
                            }
                            break;
                        }
                        else
                        {
                            if(j != dict[key[i]])
                            {
                                for (var k = 0; k < key.Length; k++)
                                {
                                    tempArray[k][i] = arr[k][j];
                                }
                                dict[key[i]] = j+1;
                            }
                        }
                    }
                }
            }
            return tempArray;
        }

C＃基于键阵列对2D数组进行排序

1 个答案: