Javascript 删除排序数组上的重复项

为了防止遗漏，问题是如何删除排序后的数组中的重复项。可以应用非常快速的算法（与未排序的数组相比）来删除重复项

• 如果您已经知道如何删除排序数组上的重复项，则可以跳过此步骤

示例：

var out=[];
for(var i=0,len=arr.length-1;i<len;i++){
    if(arr[i]!==arr[i+1]){
        out.push(arr[i]);
    }
}
out.push(arr[i]);

*排序可以是ASC或DESC，也可以是其他奇怪的方法，但重要的是每个重复的项都是相邻的

我们在

array.length-1

处停了下来，因为我们没有任何要检查的内容

然后，我们添加了最后一个元素，因为：

案例A：

，9,9,9];//我们在最后一个元素的左侧有dup

案例B：

，7,9,10];//最后一个元素左侧没有dup

如果你真的了解发生了什么，你就会知道我们没有在案例A中添加任何

9

。因此，无论我们是在案例A还是案例B中，我们都希望添加最后一个元素

---

问题：

var out=[];
for(var i=0,len=arr.length-1;i<len;i++){
    if(arr[i]!==arr[i+1]){
        out.push(arr[i]);
    }
}
out.push(arr[i]);

这就解释了，我想做同样的事情，但是在如下情况下忽略

undefined

值：

var arr=[];arr[99]=1;//0 through 98 are undefined, but do NOT hold the undefined value

我想把它们去掉。在这种情况下，我有一些真实的

未定义的
值，这些值不应该被删除

我拙劣的尝试是：

var out=[];
for (var i=0,len=arr.length; i < len - 1;) {
  var x = false;
  var y = false;

  for (var j = i, jo; j < len - 1; j++) {
    if (j in arr) {
      x = true;
      jo = arr[j];
      i = j + 1;
      break;
    }
  }
  if (x == false) {
    break;
  }

  for (var u = i, yo; u < len - 1; u++) {
    if (u in arr) {
      y = true;
      yo = arr[u];
      i = u + 1;
      break;
    }
  }
  if (y == false) {
    out.push(jo);
    break;
  }

  if (jo !== yo) {
    out.push(jo);
  }
}
out.push(arr[len - 1]);

var out=[]；
对于（变量i=0，len=arr.length；i

我真的迷路了，非常感谢您的帮助
这是一句简单的话：

uniquify( myArray.filter(function(x){return true}) )

如果您尚未编写
uniquify
（您编写的用于删除重复项的函数），您还可以使用以下两个线性函数：

var newArray = [];
myArray.forEach(function(x) {
    if (newArray.length==0 || newArray.slice(-1)[0]!==x)
        newArray.push(x)
})


阐述：

var a=[];
a[0]=1; a[1]=undefined; a[2]=undefined;
a[10]=2; a[11]=2;

根据OP，数组有“五个元素”，即使a.length==12。尽管[4]==未定义，但根据他的定义，它不是数组的元素，不应包括在内

a.filter（函数（x）{return true}）
将上述数组转换为
[1，未定义，未定义，2，2]


编辑：这最初是用
.reduce（）
而不是
.forEach（）
编写的，但是
.forEach（）
版本不太可能在效率低下的javascript实现上引入垃圾收集器和传递值问题

对于那些担心与6年历史的MIE8浏览器兼容的用户，它不支持ECMAScript标准的最后两个版本（甚至不完全符合之前的版本），您可以在中包含代码，但是如果您担心浏览器兼容性，人们应该通过GWT这样的交叉编译器进行编程。如果您使用jQuery，还可以只使用几个额外字符重写上面的内容，如
$。forEach（array，…）
我想这就是您想要的。这是一个非常简单的算法

var out = [], previous;
for(var i = 0; i < arr.length; i++) {
  var current = arr[i];
  if(!(i in arr)) continue;
  if(current !== previous) out.push(current);
  previous = arr[i];
}

var out=[]，上一个；
对于（变量i=0；i

这将在
O（N）
时间内运行。
首先，我不能完全确定您的原始代码是否符合犹太规范。在我看来，当原始列表为空时，它可能无法正常工作，因为无论发生什么情况，您都试图推送最后一个元素。最好写为：

var out = [];
var len = arr.length - 1;
if (len >= 0) {
    for (var i = 0;i < len; i++) {
        if (arr[i] !== arr[i+1]) {
            out.push (arr[i]);
        }
    }
    out.push (arr[len]);
}

一种明确的方法是打包数组（删除
未定义的
）值，并使用现有算法处理该数组上的重复项

function pack(_array){
    var temp = [],
        undefined;
    for (i=0, len = _array.length; i< len; i++){
        if (_array[i] !== undefined){
            temp.push(_array[i]);
        }   
    }
    return temp;
}

功能包（\u数组）{
var temp=[]，
未定义；
对于（i=0，len=_array.length；i
可能是这样的：

arr=[0,1,1,2,2,3,4,5,5,6,7,7,8,9,9,9];

var out = [],
    prev;

for(var i = 0; i < arr.length; i++) {
   if (!(i in arr))
      continue;

   if (arr[i] !== prev || out.length === 0) {
      out.push(arr[i]);
      prev = arr[i];
   }
}

var out=[]，
上；
对于（变量i=0；i

out.length
检查允许第一个定义的数组元素的值为
undefined
，而
prev
最初也以
undefined
开头

请注意，与原始算法不同，如果
arr
为空，则不会将未定义的值推入
out
数组

或者，如果您有一个足够新的浏览器，您可以使用，它只对已赋值的数组元素进行迭代。
一个非常简单的函数，输入数组必须排序：

function removeDupes(arr) {
  var i = arr.length - 1;
  var o;
  var undefined = void 0;

  while (i > 0) {
    o = arr[i];

    // Remove elided or missing members, but not those with a 
    // value of undefined 
    if (o == arr[--i] || !(i in arr)) {
      arr.splice(i, 1);
    }
  }
  return arr;
}

它可能更简洁，但可能会变得模糊。顺便说一句，输入数组被修改了，所以它不需要返回任何东西，但是如果返回的话可能会更方便

这是一个正向循环版本：

function removeDupes2(arr) {
  var noDupes = [],
      o;

  for (var i=0, j=0, iLen=arr.length; i<iLen; i++) {
    o = arr[i];
    if (o != noDupes[j] && i in arr) {
       noDupes.push(o);
       j = noDupes.length - 1;
    }
  }
  return noDupes;
}

功能移除UPES2（arr）{
变量noDupes=[]，
o；
对于（var i=0，j=0，iLen=arr.length；i我相信您试图实现的目标不太可能，但我可能错了

这就像一个经典的CS问题，比如一个村子里的理发师只给自己不刮胡子的人刮胡子。
如果将数组索引项的值设置为
undefined
，则它实际上不是
undefined
。
不是吗？值只有在未初始化时才能
未定义

您应该检查值是否为
null
或
未定义
。如果
null
或重复，则跳过该值，否则保留该值

如果
null
值和
function  removeDuplicateAndNull(array){

    if(array.length==0)
        return [];

    var processed = [], previous=array[0];
    processed.push(array[0]);

    for(var i = 1; i < array.length; i++) {

        var value = array[i];

        if( typeof value !== 'undefined' && value ==null) 
            continue;

        if(value !== previous || typeof value === 'undefined')
            processed.push(value);

        previous = array[i];
    }
    return processed;
}

def findDup(arr, index=1, _index=0):

    if index >= len(arr):
        return

    if arr[index] != arr[_index]:

        findDup(arr, index+1, _index+1)

    if arr[index] == arr[_index]:
        arr = deletedup(arr, index)
        findDup(arr, index, _index) #Has to remain same here, because length has changed now



def deletedup(arr, del_index):
    del arr[del_index]
    return arr

arr = [1, 2, 3, 4, 4, 4, 5, 6, 7, 7, 7, 7, 7]

findDup(arr)
print arr

//sort the array
B.sort(function(a,b){ return a  - b});
//removing duplicate characters
    for(var i=0;i < B.length; i ++){
        if(B[i]==B[i + 1])
            B.splice(i,1)
    }

splice(targetPosition,noOfElementsToBeRemoved)

function remove_duplicates(arr) {
        newArr = [];
        if (arr.length - 1 >= 0) {
            for (i = 0; i < arr.length - 1; i++) {
                // if current element is not equal to next
                // element then store that current element
                if (arr[i] !== arr[i + 1]) {
                    newArr.push(arr[i]);
                }
            }
            newArr.push(arr[arr.length - 1]);
        }
        return newArr
    }
    arr=[0,1,1,2,2,3,4,5,5,6,7,7,8,9,9,9];
    console.log(remove_duplicates(arr));

arr.filter(function (e, i, a) { return e !== a[i - 1] });

let a = [0, 1, 1, 2, 2, 3, 4, 5, 5, 6, 7, 7, 8, 9, 9, 9];

let b = arr.filter((e, i, a) => e !== a[i - 1]);

console.log(b); // [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]

arr = arr.filter((e, i, a) => e !== a[i - 1]);

function removeDuplicates(A) {
   let i = 0;
   let j = i + 1;
   while (i < A.length && j < A.length) {
      if (A[i] === A[j]) {
         A.splice(i, 1);
         j=i+1;
       } else {
         i++;
         j++;
        }
     }
    return A;
   }
console.log('result', removeDuplicates([0,1,1,2,2,2,2,3,4,5,6,6,7]))

function hello(a: [], b: []) {
     return [...a, ...b];
}
let arr = removeDuplicates(hello([1, 3, 7], [1, 5, 10]));
arr = removeDuplicates(arr);
function removeDuplicates(array) {
  return array.filter((a, b) => array.indexOf(a) === b);
}
let mainarr = arr.sort((a, b) => parseInt(a) - parseInt(b));
console.log(mainarr); //1,3,5,7,10

[1,3,7,1,5,10].filter((a, b) => [1,3,7,1,5,10].indexOf(a) === b).sort((a, b) => parseInt(a) - parseInt(b))