数组中内容按重复次数排序,并去除重复数
数组如[a,b,b,d,e,e,f,f,f,g,e,e,f,g,g]（数组仅为示例）
可看出a出现1次，b出现2此，d出现1次，e出现4此，f出现4次，g出现3次
我希望最终出现这样的排序结果：[e,f,g,b,a,d]，如有可能可同时出现这样的数组
[4，4，3，2，1，1]。或者可出现类似这样的一个数组[e$4,f$4,g$3,b$2,a$1,d$1](中间添加一个$)
要求能够效率尽可能高。
[解决办法]
我用java写了一段，测试通过，你可以参考一下，如果你用c#的话可能要在一些地方修改一下
public static void main(String[] args) {
Hashtable <String, Integer> ht = new Hashtable <String, Integer> ();
String[] harr={ "a ", "b ", "b ", "d ", "e ", "e ", "f ", "f ", "f ", "g ", "e ", "e ", "f ", "g ", "g "};
int fre; /*统计词频*/
/*填充hash表，重复出现的单词词频累加*/
for(int i=0;i <harr.length;i++){
//System.out.println(arr[i]);
if(!ht.containsKey(harr[i])){
ht.put(harr[i], 1);
}
else{
fre=(Integer)(ht.get(harr[i]));
fre+=1;
ht.remove(harr[i]);
ht.put(harr[i], fre);
}
}
/*调用getSortedHashtableByValue方法对词频排序*/
Map.Entry[] set = getSortedHashtableByValue(ht);
for (int i = 0; i < set.length; i++) {
/*以单词$词频的形式打印结果*/
System.out.println(set[i].getKey().toString()+ "$ "+set[i].getValue().toString()+ "\n ");
}
}
/*排序方法*/
@SuppressWarnings( "unchecked ")
public static Map.Entry[] getSortedHashtableByValue(Hashtable h) {
Set set = h.entrySet();
Map.Entry[] entries = (Map.Entry[]) set.toArray(new Map.Entry[set.size()]);
Arrays.sort(entries, new Comparator() {
public int compare(final Object arg0, final Object arg1) {
final int key1 = Integer.parseInt(((Map.Entry) arg0).getValue()
.toString());
final int key2 = Integer.parseInt(((Map.Entry) arg1).getValue()
.toString());
return ((Comparable) key2).compareTo(key1);
}
});
return entries;
}
[解决办法]
用我最熟悉的方法写了一个，测试通过，效率未知
List <string> str;
List <int> num;
private void button2_Click(object sender, EventArgs e)
{
//string[] arr = { "a ", "b ", "b ", "d ", "e ", "e ", "f ", "f ", "f ", "g ", "e ", "e ", "f ", "g ", "g " };
//string[] arr = { "4 ", "4 ", "3 ", "2 ", "1 ", "1 " };
string[] arr = { "e$4 ", "f$4 ", "g$3 ", "b$2 ", "a$1 ", "d$1 ", "g$3 ", "b$2 ", "g$3 " };
List <string> list = new List <string> (arr);
list.Sort();
StringBuilder sb = new StringBuilder();
foreach (string s in list)
{
sb.Append(s);
sb.Append( ", ");
}
string temp = sb.ToString();
str = new List <string> ();
num = new List <int> ();
temp = Regex.Replace(temp, @ "([^,]+,)\1* ", new MatchEvaluator(regReplace));
string[] strResult = str.ToArray();
int[] numResult = num.ToArray();
Array.Sort(numResult, strResult);
Array.Reverse(numResult);
Array.Reverse(strResult);
//输出统计结果
for(int i=0;i <numResult.Length;i++)
{
richTextBox1.Text += strResult[i] + " 重复次数： " + numResult[i] + "\n ";
}
}
//统计重复次数
private string regReplace(Match m)
{
str.Add(m.Value.Substring(0, m.Value.IndexOf( ", ")));
num.Add(Regex.Matches(m.Value, ", ").Count);
return string.Empty;
}
[解决办法]
string[] arr = { "a ", "b ", "b ", "d ", "e ", "e ", "f ", "f ", "f ", "g ", "e ", "e ", "f ", "g ", "g " };
int[] irr = new int[26];
Dictionary <string, int> dic = new Dictionary <string, int> ();
for (int i = 0; i < arr.Length; i++)
{
switch (arr[i])
{
case "a ":
irr[0]++;
if (irr[0] > 1)
{
dic[ "a "] = irr[0];
}
else
dic.Add( "a ", irr[0]);
break;
case "b ":
irr[1]++;
if (irr[1]> 1)
{
dic[ "b "] = irr[1];
}
else
dic.Add( "b ", irr[1]);
break;
case "c ":
irr[2]++;
if (irr[2]> 1)
{
dic[ "c "] = irr[2];
}
dic.Add( "c ", irr[2]);
break;
case .....
.....
default:
break;
}
}
List <string> l = new List <string> ();
//排序的时候把数字和字母颠倒，排完了再颠倒回来，呵呵好玩不
foreach (string s in dic.Keys)
{
l.Add(dic[s].ToString() + "$ " + s);
}
l.Sort();
foreach (string s in l)
{
string[] sArr = s.Split( '$ ');
Console.Write(sArr[1] + "$ " + sArr[0] + ", ");
}
效率不知道怎么样，不过代码绝对够长哒，LZ过目哦
[解决办法]
哈哈，我写了一段，比楼上都短，效率都高，而且没有用Hash表:)
using System;
using System.Collections;
namespace ConsoleApplication6
{
class Program
{
static string[] fun(string[] str)
{
ArrayList dic = new ArrayList();
for (int i = 0; i < str.Length; i++)
{
if (!dic.Contains(str[i]))
dic.Add(str[i]);
}
int diclength = dic.Count;
int[] stat = new int[diclength];
int[] temp = new int[diclength];
for (int j = 0; j < str.Length; j++)
stat[dic.IndexOf(str[j])]++;
Array.Copy(stat, temp, diclength);
Array.Sort(temp);
string[] sort = new string[diclength];
for (int k = 0; k < temp.Length; k++)
{
int mem = Array.IndexOf(stat, (temp[k]));
stat[mem] = -1;
sort[k] = dic[mem].ToString();
}
return sort;
}
static void Main(string[] args)
{
string[] str = { "a ", "b ", "c ", "b ", "b ", "d ", "a ", "c ", "c " };
str = fun(str);
foreach (string x in str)
Console.WriteLine(x);
}
}
}
[解决办法]
string[] array ={ "a ", "b ", "b ", "d ", "e ", "e ", "f ", "f ", "f ", "g ", "e ", "e ", "f ", "g ", "g "};
Hashtable table = new Hashtable();
for (int i = 0; i < array.Length; i++)
{
if (table.ContainsKey(array[i]))
{
int n = (int)table[array[i]] + 1;
table[array[i]] = n;
}
else
{
table.Add(array[i], 1);
}
}
string[] strResult = new string[table.Count];
int[] countResult = new int[table.Count];
int j = 0;
foreach (DictionaryEntry dt in table)
{
strResult[j] = dt.Key.ToString() + " : " + dt.Value.ToString();
countResult[j] = Convert.ToInt32(dt.Value);
j++;
}
Array.Sort(countResult, strResult);
for (int k = 0; k < table.Count; k++)
{
this.label1.Text = this.label1.Text + strResult[k].ToString() + "\n ";
}
