مرتب سازی حبابی در c++

Bubble Sort(a[],n)

Fori=0ton-1

Swap=false

Forj=i+1ton

ifa[j-1]>a[j]

Swap(a[j-1],a[j])

Swap=true

Breakifnotswapped

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

# Python program for implementation of Bubble Sort

defbubbleSort(arr):

    n=len(arr)

    # Traverse through all array elements

    foriinrange(n):

        # Last i elements are already in place

        forjinrange(0,n-i-1):

            # traverse the array from 0 to n-i-1

            # Swap if the element found is greater

            # than the next element

            ifarr[j]>arr[j+1]:

                arr[j],arr[j+1]=arr[j+1],arr[j]

# Driver code to test above

arr=[64,34,25,12,22,11,90]

bubbleSort(arr)

print("Sorted array is:")

foriinrange(len(arr)):

    print("%d"%arr[i]),

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

// Java program for implementation of Bubble Sort

classBubbleSort

{

    voidbubbleSort(intarr[])

    {

        intn=arr.length;

        for(inti=0;i<n-1;i++)

            for(intj=0;j<n-i-1;j++)

                if(arr[j]>arr[j+1])

                {

                    // swap arr[j+1] and arr[i]

                    inttemp=arr[j];

                    arr[j]=arr[j+1];

                    arr[j+1]=temp;

                }

    }

    /* Prints the array */

    voidprintArray(intarr[])

    {

        intn=arr.length;

        for(inti=0;i<n;++i)

            System.out.print(arr[i]+" ");

        System.out.println();

    }

    // Driver method to test above

    publicstaticvoidmain(Stringargs[])

    {

        BubbleSort ob=newBubbleSort();

        intarr[]={64,34,25,12,22,11,90};

        ob.bubbleSort(arr);

        System.out.println("Sorted array");

        ob.printArray(arr);

    }

}

/* This code is contributed by Rajat Mishra */

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

// C program for implementation of Bubble sort

#include <stdio.h>

voidswap(int*xp,int*yp)

{

    inttemp=*xp;

    *xp=*yp;

    *yp=temp;

}

// A function to implement bubble sort

voidbubbleSort(intarr[],intn)

{

   inti,j;

   for(i=0;i<n-1;i++)      

       // Last i elements are already in place    

       for(j=0;j<n-i-1;j++)  

           if(arr[j]>arr[j+1])

              swap(&arr[j], &arr[j+1]);

}

/* Function to print an array */

voidprintArray(intarr[],intsize)

{

    inti;

    for(i=0;i<size;i++)

        printf("%d ",arr[i]);

    printf("n");

}

// Driver program to test above functions

intmain()

{

    intarr[]={64,34,25,12,22,11,90};

    intn=sizeof(arr)/sizeof(arr[0]);

    bubbleSort(arr,n);

    printf("Sorted array: \n");

    printArray(arr,n);

    return0;

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

<?php  

// PHP program for implementation  

// of Bubble Sort

functionbubbleSort(&$arr)

{

    $n = sizeof($arr);

    // Traverse through all array elements

    for($i=0;$i<$n;$i++)  

    {

        // Last i elements are already in place

        for($j=0;$j<$n-$i-1;$j++)  

        {

            // traverse the array from 0 to n-i-1

            // Swap if the element found is greater

            // than the next element

            if($arr[$j]>$arr[$j+1])

            {

                $t=$arr[$j];

                $arr[$j]=$arr[$j+1];

                $arr[$j+1]=$t;

            }

        }

    }

}

// Driver code to test above

$arr=array(64,34,25,12,22,11,90);

$len=sizeof($arr);

bubbleSort($arr);

echo"Sorted array : \n";

for($i=0;$i<$len;$i++)

    echo$arr[$i]." ";  

// This code is contributed by ChitraNayal.

?>

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

// C# program for implementation  

// of Bubble Sort

usingSystem;

classGFG

{  

    staticvoidbubbleSort(int[]arr)

    {

        intn=arr.Length;

        for(inti=0;i<n-1;i++)

            for(intj=0;j<n-i-1;j++)

                if(arr[j]>arr[j+1])

                {

                    // swap temp and arr[i]

                    inttemp=arr[j];

                    arr[j]=arr[j+1];

                    arr[j+1]=temp;

                }

    }

    /* Prints the array */

    staticvoidprintArray(int[]arr)

    {

        intn=arr.Length;

        for(inti=0;i<n;++i)

            Console.Write(arr[i]+" ");

        Console.WriteLine();

    }

    // Driver method

    publicstaticvoidMain()

    {

        int[]arr={64,34,25,12,22,11,90};

        bubbleSort(arr);

        Console.WriteLine("Sorted array");

        printArray(arr);

    }

}

// This code is contributed by Sam007

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

# Python3 Optimized implementation

# of Bubble sort

# An optimized version of Bubble Sort

defbubbleSort(arr):

    n=len(arr)

    # Traverse through all array elements

    foriinrange(n):

        swapped=False

        # Last i elements are already

        #  in place

        forjinrange(0,n-i-1):

            # traverse the array from 0 to

            # n-i-1. Swap if the element  

            # found is greater than the

            # next element

            ifarr[j]>arr[j+1]:

                arr[j],arr[j+1]=arr[j+1],arr[j]

                swapped=True

        # IF no two elements were swapped

        # by inner loop, then break

        ifswapped==False:

            break

# Driver code to test above

arr=[64,34,25,12,22,11,90]

bubbleSort(arr)

print("Sorted array :")

foriinrange(len(arr)):

    print("%d"%arr[i],end=" ")

# This code is contributed by Shreyanshi Arun

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

// Optimized java implementation

// of Bubble sort

importjava.io.*;

classGFG  

{

    // An optimized version of Bubble Sort

    staticvoidbubbleSort(intarr[],intn)

    {

        inti,j,temp;

        booleanswapped;

        for(i=0;i<n-1;i++)  

        {

            swapped=false;

            for(j=0;j<n-i-1;j++)  

            {

                if(arr[j]>arr[j+1])  

                {

                    // swap arr[j] and arr[j+1]

                    temp=arr[j];

                    arr[j]=arr[j+1];

                    arr[j+1]=temp;

                    swapped=true;

                }

            }

            // IF no two elements were  

            // swapped by inner loop, then break

            if(swapped==false)

                break;

        }

    }

    // Function to print an array  

    staticvoidprintArray(intarr[],intsize)

    {

        inti;

        for(i=0;i<size;i++)

            System.out.print(arr[i]+" ");

        System.out.println();

    }

    // Driver program

    publicstaticvoidmain(Stringargs[])

    {

        intarr[]={64,34,25,12,22,11,90};

        intn=arr.length;

        bubbleSort(arr,n);

        System.out.println("Sorted array: ");

        printArray(arr,n);

    }

}

// This code is contributed  

// by Nikita Tiwari.

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

//Optimized implementation of Bubble sort

#include <stdio.h>

void swap(int*xp,int*yp)

{

    inttemp=*xp;

    *xp=*yp;

    *yp=temp;

}

//An optimized version of Bubble Sort

void bubbleSort(intarr[],intn)

{

   inti,j;

   boolswapped;

   for(i=0;i<n-1;i++)

   {

     swapped=false;

     for(j=0;j<n-i-1;j++)

     {

        if(arr[j]>arr[j+1])

        {

           swap(&arr[j], &arr[j+1]);

           swapped=true;

        }

     }

     //IFno two elements were swapped by inner loop,then break

     if(swapped==false)

        break;

   }

}

/*Function to printan array*/

void printArray(intarr[],intsize)

{

    inti;

    for(i=0;i<size;i++)

        printf("%d ",arr[i]);

    printf("n");

}

//Driver program to testabove functions

intmain()

{

    intarr[]={64,34,25,12,22,11,90};

    intn=sizeof(arr)/sizeof(arr[0]);

    bubbleSort(arr,n);

    printf("Sorted array: \n");

    printArray(arr,n);

    return0;

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

<?php  

// PHP Optimized implementation

// of Bubble sort

// An optimized version of Bubble Sort

functionbubbleSort(&$arr)

{

    $n = sizeof($arr);

    // Traverse through all array elements

    for($i=0;$i<$n;$i++)

    {

        $swapped=False;

        // Last i elements are already

        // in place

        for($j=0;$j<$n-$i-1;$j++)

        {

            // traverse the array from 0 to

            // n-i-1. Swap if the element  

            // found is greater than the

            // next element

            if($arr[$j]>$arr[$j+1])

            {

                $t=$arr[$j];

                $arr[$j]=$arr[$j+1];

                $arr[$j+1]=$t;

                $swapped=True;

            }

        }

        // IF no two elements were swapped

        // by inner loop, then break

        if($swapped==False)

            break;

    }

}

// Driver code to test above

$arr=array(64,34,25,12,22,11,90);  

$len=sizeof($arr);

bubbleSort($arr);

echo"Sorted array : \n";

for($i=0;$i<$len;$i++)

    echo$arr[$i]." ";

// This code is contributed by ChitraNayal.

?>

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

// Optimized C# implementation

// of Bubble sort

usingSystem;

classGFG

{  

    // An optimized version of Bubble Sort

    staticvoidbubbleSort(int[]arr,intn)

    {

        inti,j,temp;

        boolswapped;

        for(i=0;i<n-1;i++)  

        {

            swapped=false;

            for(j=0;j<n-i-1;j++)  

            {

                if(arr[j]>arr[j+1])  

                {

                    // swap arr[j] and arr[j+1]

                    temp=arr[j];

                    arr[j]=arr[j+1];

                    arr[j+1]=temp;

                    swapped=true;

                }

            }

            // IF no two elements were  

            // swapped by inner loop, then break

            if(swapped==false)

                break;

        }

    }

    // Function to print an array  

    staticvoidprintArray(int[]arr,intsize)

    {

        inti;

        for(i=0;i<size;i++)

            Console.Write(arr[i]+" ");

        Console.WriteLine();

    }

    // Driver method  

    publicstaticvoidMain()

    {

        int[]arr={64,34,25,12,22,11,90};

        intn=arr.Length;

        bubbleSort(arr,n);

        Console.WriteLine("Sorted array");

        printArray(arr,n);

    }

}

// This code is contributed by Sam007