Question

所以我正在经历不同的排序算法。但几乎所有的排序算法都需要2个循环来对数组进行排序。 Bubble sort＆amp; amp;的时间复杂度对于最佳情况，插入排序是O（n），但是最坏情况是O（n ^ 2），这又需要2个循环。有没有办法在一个循环中对数组进行排序？

Answer 1

这里是Python中的单循环冒泡排序：

def bubbly_sortish(data):
    for _ in xrange(len(data)**2):
        i, j = _/len(data), _%len(data)
        if i<j and data[i] > data[j]:
            data[i], data[j] = data[j], data[i]

A = [5, 1, 2, 3, 5, 6, 10]
bubbly_sortish(A)

print A

当然这是个玩笑。但这表明循环次数与算法复杂性无关。

现在，如果你问是否可以用O（n）比较对数组进行排序，不，it's not possible。对于基于比较的排序算法，下限是Ω（n log n）。

Answer 2

在一般情况下，你有平均O（n lg n）。

但在特殊情况下，最好的情况是O（n），我认为它足够接近你所调用的＃34;只有一个循环＆＃34;，即使实现可能显示多个for关键字的实例。而且好消息是，你不依靠运气来让你的最佳案例成为现实。如果您了解有关数据的一些属性，则可以选择一些特定的算法。例如：

3-way quicksort在O（n）附近运行时，如果你有很多只有几个不同排序键的项目（将服务器日志条目视为项目，日期作为键）。
如果您的键很容易索引（如字符集或小整数），并且索引具有已知的上限k，则计数排序在O（n + k）中运行。
如果您正在处理最大长度为w的字符串，则Burstsort将在O（wn）中运行。

这只是三个例子。对于许多类型的约束数据集，还有很多方法可以从头脑中回忆起来。如果你有一个真实的案例，其中O（n lg n）不够好，那么值得做一些适当的研究，如果你在数据中发现了一些有趣的属性

Answer 3

使用C ++进行单循环冒泡

int a[7]={5,7,6,2,4,3,1};

int temp = 0;

int j = 0;

for(int i = 0 ; i<a[]-1 ; i++)
{
    int flag = 0;
    if(a[i]>a[i+1])
    {
        temp = a[i];
        a[i] = a[i+1];
        a[i+1] = temp;
        flag = 1;
    }       
    if(i == 7-2-j)
    {
        if(!flag) break;
        i = -1;
        j++;
    }
}

Answer 4

int list[] = { 45, 78, 22, 96, 10, 87, 68, 2 };
    for (int i = 1; i < list.length; i++) {
        if (list[i] < list[i - 1]) {
            list[i] = list[i] + list[i - 1];
            list[i - 1] = list[i] - list[i - 1];
            list[i] = list[i] - list[i - 1];
            i = 0;
        }
    }
    System.out.print("Sorted array is : ");
    for (int i = 0; i < list.length; i++) {
        System.out.print(list[i] + " ");
    }

Answer 5

以下代码在php中。您可以在https://paiza.io/projects/4pAp6CuB-e9vhGIblDNCZQ上测试代码。

  $a = [8,3,4,9,1];
    for($i=0;$i<count($a)-1;$i++){
        if($a[$i] > $a[$i+1]){
            $temp = $a[$i];
            $a[$i] = $a[$i+1];
            $a[$i+1] = $temp;
            $i = -1;
        }
    }
    print_r($a);

Answer 6

公共类SinleLoopeSorting {

public static void main(String[] args) {
    Integer[] x = new Integer[] { 1, 7, 8, 0, 4, 2, 3 };

    for (int i = 0; i < x.length - 1; i++) {
        if (x[i] > x[i + 1]) {
            int p = x[i];
            x[i] = x[i + 1];
            x[i + 1] = p;
            i = -1;
        }
    }
    for (int i = 0; i < x.length; i++) {
        System.out.println(x[i]);
    }
}

}

Answer 7

public void sortArrayUsingSingleLoop(int[] intArray) {
        int temp;
        boolean swap = false;
        for(int i=0;i<intArray.length-1;i++){
         if(intArray[i]>intArray[i+1]){
             temp=intArray[i];
             intArray[i]=intArray[i+1];
             intArray[i+1]=temp;
             swap=true;
         }

         if(swap &&i==intArray.length-2){
            i=-1;swap=false;
         }
        }

    }

Answer 8

javascript:
function bruteForce(arr){
    for(var i=0;i<arr.length; ){
        if(arr[i+1]< arr[i]){
            var temp = arr[i];
            arr[i]=arr[i+1];
            arr[i+1] = temp;
            i--;
            if(i === -1) i=0;
        }else i++;
    }

    return  arr;
 }

alert(bruteForce([2,3,4,5,6,23,1,1]));

复制代码并粘贴浏览器的URL并按Enter键。如果遗漏了javascript:，请将其添加。

Answer 9

单循环数组排序：

def combine_names(apps, schema_editor):
    Person = apps.get_model("yourappname", "Person")
    for person in Person.objects.all():
        person.name = "%s %s" % (person.first_name, person.last_name)
        person.save()

class Migration(migrations.Migration):    
    dependencies = [
        ('yourappname', '0001_initial'),
    ]    
    operations = [
        migrations.RunPython(combine_names),
    ]

Answer 10

以下是给定示例的工作版本：

如果您知道要排序的值的范围，则可以采用一种非常快速有效且合乎逻辑的方法来解决问题，例如 0 <= val <= 100其中val是整数。

然后你可以用两个循环中的单个读写操作来完成它...一个用于读取数组，一个用于写入它的排序：

使用第二个数组，其中索引表示值0-100，在其中存储每个值0-100遇到的次数，例如val = 100可能在目标数组中存在234次... < / p>

只有一个用于读取的循环和一个用于写入的循环，这在计算上和一个循环一样有效，它可以同时执行读取和写入，并且比使用比较的循环更快...如果你坚持，你可以在单个循环中执行两倍于目标数组的长度，并在新阵列写操作上将i值重置为零。

第二个循环只是按顺序写入第一个数组中遇到的每个值的计数。

Answer 11

用于插入排序的单for循环：

强文

function insertionSort (array) {
    for(var i = 1 ; i < array.length ;){
        if(array[1] < array[0]) {
                temp = array[i];
                array[i] = array[i -1];
                array[i -1] = temp; 
         }
        if(array[i] < array[i-1]){
            var temp = array[i]
            array[i] = array[i -1]
            array[i -1] = temp
            i--
        } else{i++}
    }
    return array
}

Answer 12

以下是仅使用单循环对数组进行排序的代码。

var array = [100, 110, 111, 1, 3, 19, 1, 11, -10]
var i = 1

while i < array.count - 1 {
    if array[i] > array[i + 1] {
        let temp = array[i];
        array[i] = array[i + 1];
        array[i + 1] = temp;
        i = -1;
    }
    i = i + 1;
}
print(array)

Answer 13

迟到聚会，但希望对你有帮助

java解决方案

for(int i=1;i< arr.length;i++) {
        if(arr[i] < arr[i-1] ){
            arr[i-1] += arr[i];
            arr[i] = arr[i-1] - arr[i];
            arr[i-1] -= arr[i];
            i=0;
        }
}

Answer 14

<块引用>

您可以使用 while 循环并使用索引

       int i=0;
       int a[]={1,2,3,4,7,3};
       while(i<a.length)
       {
           if((i+1<a.length && a[i]>a[i+1]) )
           {
                swap(i,i+1,a);
               i=i-1;
           }
         if(i-1>=0 && a[i]<a[i-1] )
             {
             swap(i,i-1,a);
            i=i-1;
             }
           else
               i++;
       }

Answer 15

就这么简单，请轻松一步

decimal=","

console.log(arr)

Answer 16

这可用于通过单个循环对数组进行排序：- 要点：

将i的值更新为-1，以使它在i ++之后始终从0开始
减少数组的长度（size--），因为每次循环完成时，最大价值元素都会在最后结束

代码：

void sort(int *arr,int size){
    int i;
    for (i = 0; i <size; i++){
        if(arr[i]>arr[i+1]){
            arr[i]=arr[i]+arr[i+1];
            arr[i+1]=arr[i]-arr[i+1];
            arr[i]=arr[i]-arr[i+1];
            if(i==size-2){
                printf("%s\n","inside if loop" );
                i=-1;
                size--;
            }
        }
    }
}

Answer 17

Optional.ofNullable(loginCredential.getUser())
        .ifPresent(user -> user.setLoginCredential(loginCredential));
loginCredentialRepo.save(loginCredential);

Answer 18

public int find2ndLargest() {
    int[] arr = {1,3,14,25,7,20,11,30};
    int temp;

    // sort array
    for (int i=0;i<arr.length-1;i++) {
        if (arr[i]>arr[i+1]) {
            temp = arr[i];
            arr[i]=arr[i+1];
            arr[i+1]=temp;
            i=0;
        }
    }
    return arr[arr.length-2];
}

Answer 19

    #include<stdio.h>

    void sort(int a[],int n,int k,int w)
    {   
      int i,j,z,key;
      n=n-1;
      j = k+1;
      key = a[j];
      i = j-1;
      while(i>0 && a[i]>key)
      {
        a[i+1] = a[i];
        i = i-1;
      }
      a[i+1] = key;
      k = k + 1;
      if(n!=0)
      {
       sort(a,n,k,w);
      }
    }

  int main()
 {
    int i,n,w,k=1,z=5,g;
    printf("enter the size of an array\n");
    scanf("%d",&n);
    g=n;
    int a[n];
    for(i=1;i<=n;i++)
    {
        scanf("%d", &a[i]);
    }
    w = n;
    sort(a,n-1,k,w);

    for(i = 1; i <= n; i++)
    {
        printf("%d", a[i]);
    }
 }

这是解决方案。这可能会对您有所帮助。

Answer 20

使用python：

def sort(array):
    n = len(array);
    i = 0;
    mod = 0;
    if(len(array)<= 1):
        return(array)

    while n-1:
        if array[mod] > array[mod+1]:
            array[mod], array[mod+1] = array[mod+1], array[mod]

        mod+=1
        if mod+1 >= n:
            n-=1
            mod = 0

    return array

Answer 21

在单循环中使用Java对数组进行排序：

    public int[] getSortedArrayInOneLoop(int[] arr) {

    int temp;
    int j;

        for (int i = 1; i < arr.length; i++) {
        j = i - 1;

            if (arr[i] < arr[j]) {

            temp = arr[j];
            arr[j] = arr[i];
            arr[i] = temp;
            i = 1;

            }

        }

    return arr;

    }

Answer 22

以下代码在PHP中用于对数组的最佳情况进行排序。 https://paiza.io/projects/r22X0VuHvPQ236jgkataxg

<?php
function quicksort($a){
    $n = count($a);
    $lt = [];
    $gt = [];

    if($n < 2){
       return $a;
    }else{
        $f = $a[0];
    }

    for($i = 1;$i < $n ;$i++){
        if($a[$i] > $f){
            $gt [] = $a[$i];
        }else{
            $lt [] = $a[$i];
        }
    }

    return array_merge(quicksort($lt),array($f),quicksort($gt));
}


$ar = [7,4,3,6,5,1,2];
echo "Input array => ".implode(' , ',$ar).'<br>';
$a = quicksort($ar);

echo "Output array => ".implode(' , ',$a);;

?>

Answer 23

使用单循环（javascript）对数组进行排序

var arr = [4,5,2,10,3,7,11,5,1];
for(var i = 1; i < arr.length; i++)
{       
    if(arr[i] < arr[i-1])
    {
        arr[i] = arr[i] + arr[i-1];
        arr[i-1] = arr[i] - arr[i-1]; 
        arr[i] = arr[i] - arr[i-1];              
        i=0;
    } 
}

输出：arr = [1、2、3、4、5、5、7、10、11]

Answer 24

def my_sort(num_list):
    x = 0
    while x < len(num_list) - 1:
        if num_list[x] > num_list[x+1]:
            num_list[x], num_list[x+1] = num_list[x+1], num_list[x]
            x = -1
        x += 1
    return num_list

print(my_sort(num_list=[14, 46, 43, 27, 57, 42, 45, 21, 70]))
#output [14, 21, 27, 42, 43, 45, 46, 57, 70]

如何在单个循环中对数组进行排序？

24 个答案: