冒泡排序说明

Question

I am writing a bubble code program for my intro to Java class, and it is a very simple assignment. I am just curious as to if my code is correct. The thing is, my code works, but it is different from the normal solution I have seen other people post. I am not sure if I have just done a different sorting method, or if I have just written a different version of bubble sorting.

So below is the code I have written:

import java.util.Arrays;
import java.util.Random;

public class BubbleSort
{
    public static void main(String[] args)
    {
        Random ran = new Random();

        int[] list = new int[10];

        for(int i = 0; i < list.length; i++)
            list[i] = ran.nextInt(50);

        System.out.println(Arrays.toString(list));
        System.out.println(Arrays.toString(bubbleSort(list)));
    }

    public static int[] bubbleSort(int[] list)
    {
        int temp;

        for(int i = 0; i < list.length; i++)
        {
            for(int j = 0; j < list.length - 1; j++)
            {
                if(list[j] > list[j + 1])
                {
                    temp = list[j];
                    list[j] = list[j + 1];
                    list[j + 1] = temp;
                }

            }
        }

        return list;
    }
}

And that works perfectly fine. But I am not sure if it is actually 'bubble sorting'.

Most people have this in their for loop when they are writing this same program

for(int j = 0; j < list.length - 1 - i; i++)

The question I have is what is the point of doing the list.length - 1- i whenever what I have, list.length - 1 works perfectly fine?

Have I accidentally done a different form of sorting? They both work I am just curious as to why people do list.length - 1 - i

Answer 1

@markspace gave me the correct answer in the comments so all credit to him.

I will just post this for the sake of proving his answer. I tested my code with 10,000 integers and created a timer to see how long it takes. Whenever I used my code which just had j < list.length - 1 sorting 10,000 integers took 297 milliseconds on average. Once I changed my for loop to have j < list.length - 1 - i it sorted the loop about 35% faster at just 196 milliseconds. As stated by mark, adding the - i just prevents the program from re-checking the last elements which are already sorted thus saving time.