數組去重離子
❶ javascript數組去重不理解
arr是要去重的數組，ret是去重後得到的新數組，hash相當於一個Map，用來記錄某個元素在ret中是否回已經存在了。
程序遍歷答arr，以每個元素的類型+這個元素作為Map的key，如果hash中已經有這個key了，那麼就不把該元素加到ret中，如果沒有那就加到ret中，同時把這個新key加到hash中。
if (hash[key] !== 1)實際上就是判斷當前元素是否出現過
❷ JS數組去重
用到了數組的splice(index,endlength,item)方法，刪除數組中的項，裡面可以有三個參數
注意 會改變原數組
返回值 刪除的項組成的新數組
代碼如下：
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
</head>
<body>
<script type="text/javascript">
var arr = [{a:1,b:1,c:1,d:1,e:1},{a:1,b:1,c:1,d:2,e:2},{a:2,b:2,c:2,d:1,e:1}];
//循環開始
for(var i=0;i<arr.length-1;i++){
//遍歷數組中a b c 都一樣的才往下進行
if((arr[i].a == arr[i+1].a) && (arr[i].b == arr[i+1].b) && (arr[i].c == arr[i+1].c)){
//刪除重復的那一個元素,改變了數組
arr.splice(i,1);
//d的值累加
arr[i].d += arr[i+1].d;
console.log(arr)
}
}
</script>
</body>
</html>
❸ 求助：數組去重問題
第一種方法(只學到數組的看):
定義一個新的數組長度和舊數組的長度一樣,存儲除去重復數據的舊數組的數據和0,
public static void main(String[] args) {
// 獲取一個無重復元素的數組
int[] arr = new int[] { 11, 22, 22, 33, 44, 55, 44, 66, 66, 66 };
// 先確定新數組的長度
int[] newArr = new int[arr.length];
int index = 0; // 新數組存儲元素索引(或者說無重復的個數)
outer: for (int i = 0; i < arr.length; i++) {
for (int j = i + 1; j < arr.length; j++) {
//當數據重復時,跳出外圈循環
if (arr[i] == arr[j]) {
continue outer;
}
}
// 後面沒有與當前元素重復的值,保存這個數
newArr[index] = arr[i];
index++;
}
// 新數組中存儲著無重復的值和後面一些無效的0
int[] result = new int[index];
for (int i = 0; i < index; i++) { // 遍歷有效值個數
result[i] = newArr[i];
}
System.out.println(Arrays.toString(result));
}
第二中方法:
/*
* 一個一個刪除,有一個刪一個.
* 把數組中的一個數據和其他數據進行比較,如果有一個重復時,就直接開始創建新數組把重復的元素去除,並重新賦給舊數組
*/
public static void main(String[] args) {
int[] arr = { 1, 1, 1, 1, 5, 3, 3, 4, 8, 8, 8, 8 };
for (int i = 0; i < arr.length; i++) {
for (int j = i + 1; j < arr.length; j++) {
if (arr[i] == arr[j]) {
// return返回的數字的地址而非數組的數值(不懂的華看一下變數的 名 和所代表的數據地址的關系)
arr = aa(arr, j);
// 改變的數組中新數據頂替了覆蓋數組的就數據,所以還要重新比較一次
/*
* { 1, 1, 1, 1, 5, 3, 3, 4, 8, 8, 8, 8 }; 下標 0 1 2
* 當下標為1被刪除了 ,下標2的數據補上 0 2 這個新元素還沒有被比較,所以要再比較一次,所以j--
*/
j--;
}
}
}
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
// 需要獲得舊數組和重復元素的下標,然後改成新數組並返回出來新數組
public static int[] aa(int[] arr, int index) {
// 新數組,沒發現一個就去除一個.所以長度-1 就行
int[] newArr = new int[arr.length - 1];
// 因為就數組的下標要去除一個,又不知道那個,所以定義一個變數自增來當新數組的下標
int c = 0;
for (int i = 0; i < arr.length; i++) {
// 判斷傳進來的那個重復的下標和數組中的下標相等時,下標的元素就不用重新賦給新數組了
if (index != i) {
newArr[c] = arr[i];
c++;
}
}
return newArr;
}
第三種方法;
/* 相同的一起刪除,當發現相同的元素,先統計重復的個數,然後一起刪掉,得到新數組賦給舊數組 */
public static void main(String[] args) {
int[] arr = { 8, 1, 1, 1, 1, 5, 3, 3, 4, 8, 8, 8, 8 };
arr = a2(arr);
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
public static int[] a2(int[] arr) {
int a = 0;
for (int i = 0; i < arr.length - 1; i++) {
for (int j = i; j < arr.length - 1; j++) {
// 如果有相同的,就統計出相同元素的個數
if (arr[i] == arr[j + 1]) {
a += 1;
}
}
if (a != 0) {
// return返回的數字的地址而非數組的數值(不懂的華看一下變數的 名 和所代表的數據地址的關系)
arr = a1(arr, arr[i], a);
// 一個元素個數獲得到,統計變數清零,等待回去下一個元素重復的個數
a = 0;
}
}
return arr;
}
// 刪除裡面重復的元素
public static int[] a1(int[] arr, int arr2, int a) {
// 因為就數組的下標要去除一個,又不知道那個,所以定義一個變數自增來當新數組的下標
int c = 1;
// 獲得新數組的長度,就是舊數組減去元素重復的次數
int[] aa = new int[arr.length - a];
// 重復的元素也要保留一個
aa[0] = arr2;
for (int i = 0; i < arr.length; i++) {
// 不與重復元素相同的元素都非給新數組
if (arr2 != arr[i]) {
aa[c++] = arr[i];
}
}
return aa;
}515253
❹ 數組去重的意義
vararr=[1,1,2,2,2,3,3,4,5,1,2,3];
arr.sort();
varstr=arr.join(",");
str=str.replace(/([^,]+,)1+/g,"$1");
console.log(str);
❺ JAVA數組去重問題
我這有個笨辦法供樓主參考：
把vector中元素都取出來放到一個數組中，
根據數據的實際情況，回
選擇不同的答時間復雜度為log2N的排序演算法進行排序，
然後新建一個鏈表，
結點為保存數據和頻率的類，
遍歷排序後的數組，
如果鏈表的尾結點與數組中當前元素相同，
將尾結點的頻率加1，
否則append一個頻率為1的結點，
希望大牛們能給出更好的解法
❻ 有序數組去重的幾種演算法
這個問題的意思是，如果假設一個數組中存在重復的數據項，那麼就中保留重復數據項中的一個。也就是說最終輸出的結果數組中不容許存在重復數據項，所以因為這里涉及到重復數據項的問題，所以立馬想到了集合(Set)這個數據結構，因為它是不容序存在重復數據項的數據結構，
思路1.也就是將數組中的所有元素插入到一個Set中，利用Set的自動剔除重復數據項的功能，將導致所有重復數據項沒有辦法插入成功，也就是add方法
返回false,然後調用toArray方法，返回這個集合所對應的數組。那麼這個數組就是一個沒有重復數據項的數組，利用這個方法，通過比較結果數組和
源數組之間的大小，查看源數組中到底是否存在重復數據項。
思路2.除了利用Set這個數據結構不容序存在重復數據項的功能之外，還有一種很容易想到的方法，也就是對整個數組進行排序，然後遍歷排序之後的數組，將重復數據項，清除掉。
思路1的實現：
public static int[] noDup(int[] array) {
Set<Integer> set = new
HashSet<Integer>();
for (int i :
array)
set.add(i);
Integer[]
integers = (Integer[]) set.toArray();
int[] result
= new int[integers.length];
for (int i =
0; i < integers.length; i++)
result[i] =
integers[i];
return
result;
}
思路2的實現:
使用快速排序等演算法對數組進行排序，這個排序過程不在介紹。假設下面這個演算法的輸入是一個幾經排好序的數組。
for (int i = 0; i < array.length - 1; i++) {
if (array[i]
== array[i + 1]) {
array[i] =
-1;
}
}
通過上面這段代碼就能夠實現把數組中所有的重復數據項只保留一個，其它的置為-1或者根據實際情況置成其它值。然後遍歷數據，刪除所有位-1的數據項，並且將數組中包含的記錄個數不斷減少即可。
❼ js數組去重：string.split(",")
基本思路，對象的屬性名不能重復（注意不是屬性值），重復的話覆蓋。所以專得到這樣屬的代碼：
varstr="1,2,4,5,2,4";//document.getElementById("textbox1").innerText;
vars=str.split(',');
vardic={};
for(vari=s.length;i--;){
dic[s[i]]=s[i];
}
varr=[];
for(varvindic){
r.push(dic[v]);
}
alert(r.join());//-----------1,2,4,5
❽ js中數組去重的幾種方法
function clear(arr) {
// 1 如何獲取數組中每一個元素出現的次數
var o = {}; // 1.1 記錄數組中元素出現的次數
for (var i = 0; i < arr.length; i++) {
var item = arr[i]; // 數組中的每一個元素
// o[item] = 1;
// 1.2 判斷o對象是否有當前遍歷到的屬性
if (o[item]) {
// 如果o[item] 存在，說明次數不為1
o[item]++;
} else {
// 如果o[item] 不存在，說明是第一次出現
o[item] = 1;
}
}
// console.log(o);
// 2 生成一個新的數組，存儲不重復的元素
var newArray = [];
// 2.1 遍歷對象o中的所有屬性
for (var key in o) {
// 2.2 判斷o對象中當前屬性的值是否為 1 如果為1 說明不重復直接放到新數組中
if (o[key] === 1) {
newArray.push(key);
} else {
// o對象中當前屬性 次數不為1 ，說明有重復的，如果有重復的話，只存儲一次
// 判斷當前的newArray數組中是否已經有該元素
if (newArray.indexOf(key) === -1) {
newArray.push(key);
}
}
}
return newArray;
}
var array = ['c', 'a', 'z', 'a', 'x', 'a'];
var newArray = clear(array);
console.log(newArray);
❾ JS數組去重的幾種常見方法
js 數組去重
1
註：應該也可以適用於 object數組，但是本人沒有進行驗證，貼出來僅供你參考
第一種是比較常規的方法思路：1.構建一個新的數組存放結果2.for循環中每次從原數組中取出一個元素，用這個元素循環與結果數組對比3.若結果數組中沒有該元素，則存到結果數組中代碼如下:
Array.prototype.unique1 = function(){ var res = [this[0]]; for(var i = 1; i < this.length; i++){ var repeat = false; for(var j = 0; j < res.length; j++){ if(this[i] == res[j]){ repeat = true; break; } } if(!repeat){ res.push(this[i]); } } return res;}var arr = [1, 'a', 'a', 'b', 'd', 'e', 'e', 1, 0]alert(arr.unique1());
第二種方法比上面的方法效率要高思路：1.先將原數組進行排序2.檢查原數組中的第i個元素 與 結果數組中的最後一個元素是否相同，因為已經排序，所以重復元素會在相鄰位置3.如果不相同，則將該元素存入結果數組中代碼如下：
Array.prototype.unique2 = function(){ this.sort(); //先排序 var res = [this[0]]; for(var i = 1; i < this.length; i++){ if(this[i] !== res[res.length - 1]){ res.push(this[i]); } } return res;}var arr = [1, 'a', 'a', 'b', 'd', 'e', 'e', 1, 0]alert(arr.unique2());
二種方法也會有一定的局限性，因為在去重前進行了排序，所以最後返回的去重結果也是排序後的。如果要求不改變數組的順序去重，那這種方法便不可取了。第三種方法（推薦使用）思路：1.創建一個新的數組存放結果2.創建一個空對象3.for循環時，每次取出一個元素與對象進行對比，如果這個元素不重復，則把它存放到結果數組中，同時把這個元素的內容作為對象的一個屬性，並賦值為1，存入到第2步建立的對象中。說明：至於如何對比，就是每次從原數組中取出一個元素，然後到對象中去訪問這個屬性，如果能訪問到值，則說明重復。代碼如下：
Array.prototype.unique3 = function(){ var res = []; var json = {}; for(var i = 0; i < this.length; i++){ if(!json[this[i]]){ res.push(this[i]); json[this[i]] = 1; } } return res;}var arr = [112,112,34,'你好',112,112,34,'你好','str','str1'];alert(arr.unique3());