欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

NET 在一个数组中查找另一个数组所在起始位置(下标从0开始,未找到返回-1)

程序员文章站 2022-06-20 14:49:09
问题: 如果 search 在 dist 中顺序出现而不要求连续出现,那代码应该如何修改?如何计算这种匹配的可能性? 数组 search=[5,4,6],在数据 dist=[1,5,5,4,3,4,5,6]的起始位置是1 (因为dist下标{1,3,7}和下标{1,5,7}的元素都等于 search ......

问题:

如果 search 在 dist 中顺序出现而不要求连续出现,那代码应该如何修改?如何计算这种匹配的可能性?

数组 search=[5,4,6],在数据 dist=[1,5,5,4,3,4,5,6]的起始位置是1

(因为dist下标{1,3,7}和下标{1,5,7}的元素都等于 search=[5,4,6],故有两种可能)

        /// <summary>
        /// 如果 search 在 dist 中顺序出现而不要求连续出现,那代码应该如何修改?如何计算这种匹配的可能性?
        /// 例如:
        /// 数组 search=[5,4,6],在数据 dist=[1,5,5,4,3,4,5,6]的起始位置是1
        /// (因为dist下标{1,3,7}和下标{1,5,7}的元素都等于 search=[5,4,6],故有两种可能)
        /// </summary>
        private static void indexof()
        {
            var search = new int[] { 5, 4, 6 };
            console.writeline($"连续出现的数组:{string.join("-", search)}");
            var dist = new int[] { 1, 5, 5, 4, 3, 4, 5, 6 };
            console.writeline($"需要比对的数组:{string.join("-", dist)}");
            var dictionary = new dictionary<object, list<int>>();
            //  按照数组顺序初始化字典
            foreach (var item in search)
            {
                dictionary.add(item, new list<int>());
            }
            //  把search中元素的下标记录下来
            for (int i = 0; i < dist.length; i++)
            {
                var key = dist[i];
                if (array.indexof(search, key) > -1)
                {
                    if (dictionary.containskey(key))
                    {
                        dictionary[key].add(i);
                    }
                }
            }
            var group = new list<list<int>>();
            console.writeline("分组前:");
            foreach (var key in dictionary.keys)
            {
                console.writeline($"key:{key}\t下标集合:{string.join("-", dictionary[key])}");
            }
            add(new list<int>(), -1, 0, search, dictionary, group);
            console.writeline("分组后:");
            foreach (var item in group)
            {
                console.writeline($"下标集合:{string.join("-", item)}");
            }
        }

        /// <summary>
        /// 递归添加
        /// </summary>
        /// <param name="list">需要添加的集合</param>
        /// <param name="parentkey">上一次的key,当前循环key要比上一次大</param>
        /// <param name="index">下标</param>
        /// <param name="search"></param>
        /// <param name="dictionary"></param>
        /// <returns></returns>
        private static void add(list<int> list, int parentkey, int index, int[] search, dictionary<object, list<int>> dictionary, list<list<int>> group)
        {
            if (search.count() <= index)
            {
                //  匹配项超过数组长度,终止
                group.add(list);
                return;
            }

            //  当前下标的值
            var key = search[index];
            if (dictionary.containskey(key))
            {
                var itemlist = dictionary[key];
                //  循环值
                for (int j = 0; j < itemlist.count(); j++)
                {
                    var itemkey = itemlist[j];
                    //  当前循环key要比上一次大
                    if (itemkey < parentkey)
                    {
                        return;
                    }
                    var clone = clone(list);
                    clone.add(itemkey);
                    add(clone, itemkey, index + 1, search, dictionary, group);
                }
            }
        }

        /// <summary>
        /// 克隆
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        private static list<int> clone(list<int> list)
        {
            var clone = new list<int>();
            foreach (var item in list)
            {
                clone.add(item);
            }
            return clone;
        }