这就是散列中的键被称为'index'的原因，请考虑一下。

Question

只想重新排列数组中的数据，以便类似的项目不会紧挨着每个数据。不应该从数组中删除数据，如果无法重新排列，则可以将数据放在数组的末尾。但保持原始秩序是必要的。

实施例

   1 1 2             =>   1 2 1 
   1 1 1 2 3         =>   1 2 1 3 1
   1 1 2 1 3 3 5 1   =>   1 2 1 3 1 3 5 1
   1 1 1 1 1 1 2     =>   1 2 1 1 1 1 1
   8 2 1 3 7 2 5     =>   rearrange not needed
   8 2 2 2 7 2 5 2   =>   8 2 7 2 5 2 2      // keep the original order

编辑：添加了显示保持原始订单的示例

Answer 1

对数组进行排序

在较小的偶数索引处交换元素及其较高的对映对象：

for ( i=0; i < arr.length/2; i+=2 )
    arr.swap(i,arr.length-1-i);

编辑：好的，我们应该重新定义对映对手。也许这个更好：混合第一和第三四分位数（在图中表示为x，y），以及混合第二和第三四分位数（表示为u，v，w）。让对手提升并行。

        25%  50%  75%
         |    |    |
    -----[----[----[----
    11122334455667788999
     x y u v w x y u v w  <-- u, v, w, x, y indicate swap positions
    16172839495161738495

Answer 2

嗯。 Bubblesort浮现在脑海中，但有三元素比较;也就是说，如果item[x]和item[x + 1]相同且item[x + 2]不同，则交换item[x + 1]和item[x + 2]。重复遍历列表，直到没有发生交换。执行顺序当然是可怕的，但这应该满足你的需求。

Answer 3

在我掌握了你所追求的内容之后，这是一个可能的解决方案

对数组进行分区

[1,1,1,8,8,8,2,3,3,4,1,1,1,2,2] -> [[3,1],[3,8],[1,2],[2,3],[1,4],[3,1],[2,2]]

（读3次1次，3次8次，依此类推）

对于i（次数> 1）的每个分区条目p[i][0] >1：
- 选择“有效”排名j（所以p[j][1] != p[i][1] && p[j+1][1] != p[i][1]）
- 减少p[i][0]元素并在位置j的分区中插入[p[i][1],1]
如果没有这样的职位，请将其遗漏。

这应该具有线性时间复杂度（每个数字的书籍保持有效位置）。

Answer 4

Java：这样的东西？

void resortArray(ArrayList<Integer> arr) {
  for(int i = 0; i < arr.size(); i++) //loop trough array
    if(arr.get(i) == arr.get(i + 1)) { //if the next value is the same as current one
      for(int j = i+2; j < arr.size(); j++) { //loop again trough array from start point i+2
        if(arr.get(i+1) != arr.get(j)) { //swap values when you got a value that is different
          int temp = arr.get(i+1);
          arr.set(i+1, arr.get(j));
          arr.set(j, temp);
          break;
        }  
      }
    }
  }
}

Answer 5

将数组填充到类var中，然后就可以在其上运行自定义排序方法而无需更改它。恭喜，您刚刚创建了一个新的nosql数据库。

什么吓到每个人都失去了原来的顺序。

这就是散列中的键被称为'index'的原因，请考虑一下。

class Dingleberry
  {

   private $shiz= array();

    function __construct(array $a) { $this->shiz = $a; }

##### PUBLIC

    public function unmolested() { return $this->shiz; }

    /* @see http://www.php.net/manual/en/ref.array.php */
    public function sort($type)
        {
        switch ($type)
            {
            case 'key_reverse': return krsort($this->shiz); break;
            # Check all the php built in array sorting methods to 
                    # make sure there is not already one you want
                    # then build this out with your own
            }
        }

}

Answer 6

在javascript中，我可能会这样做：

    var arr = [ 1, 1, 1, 2, 3 ];
    var i = 0, len = arr.length;

    while (i < len - 1) {
        if (arr[i] == arr[i+1]) {
            //index is equal to it's partner.
            if (arr[i+2] && arr[i] == arr[i+2]) {
                // 3 equal values in a row, swapping won't help. Need to recheck this index in this case.
                var tmp = arr[i];
                arr.splice( i, 1 );
                arr.push( tmp );
            } else {
                // Swap the next and 2nd next index.
                var tmp = arr[i+1];
                arr[i+1] = arr[i+2];
                arr[i+2] = tmp;
                i++;
            }
        } else {
            // this index is fine, move on.
            i++;
        }
    }

这是一个快速的例子，编码风格可能会被大量清理

Answer 7

假设包含0到9之间的数字的数组：
类似于铲斗在某种程度上排序

int B[10];//buckets
diff=0;//how many different digits appeared

for(i=0;i<A.length;i++)
{
 x=A[i];
 if(B[x]==0)
 {
  diff++;
 }
 B[x]++;
}//loaded
while(diff>=0)//now to place back to array makes an interleaving
{
 for(digit=0;digit<10;digit++)
 {
  if(B[digit]<>0)
  {
   A[B[digit]+diff]=digit;
   B[digit]--;
  }
 }
 diff--;
}

Answer 8

获取整个阵列并扫描它以获得重复数据。遇到傻瓜时，请记住它们的位置。因此对于像2 1 2 2 * 3 3 * 3 * 4 4 * 2 2 * 5这样的东西应该记住星星。

现在看看“记住”的东西，你有2个2，3个和4个

现在我将那些LISTS排在第一位（2位和3位）最少（4位）

现在只取最多的不会复制当前的“Front”（因为2个副本将是3）并将其移到前面，然后将其从列表中删除。

重复直到列表为空。第二次通过你的列表将从“3”开始，你将有2 2的3和4，所以你将把2中的一个放在前面......

如果你有任何一个（它只能是一个数字），就把它放在最后..

完成，蛋糕。

如何重新排列数组中的数据，以便两个相似的项目不是彼此相邻？

8 个答案:

这就是散列中的键被称为'index'的原因，请考虑一下。