자바는 알고리즘인가요?-java지도 시간-php.cn

자바는 알고리즘인가요?

java는 알고리즘이 아닙니다.

Java는 객체 지향 프로그래밍 언어이자 널리 사용되는 컴퓨터 프로그래밍 언어입니다 . 크로스 플랫폼, 객체 지향 및 일반 프로그래밍 기능을 갖추고 있습니다. , 엔터프라이즈 수준의 웹 애플리케이션 개발 및 모바일 애플리케이션 개발에 널리 사용됩니다.

Algorithm은 문제 해결 방법에 대한 정확하고 완전한 설명을 의미하며, 문제 해결을 위한 일련의 명확한 지침입니다. Algorithm은 체계적인 사용을 나타냅니다. 문제에 대한 해결책을 설명하는 방법 전략적 메커니즘. 즉, 특정 표준화된 입력에 대해 제한된 시간 내에 필요한 출력을 얻는 것이 가능합니다. 알고리즘에 결함이 있거나 문제에 적합하지 않은 경우 알고리즘을 실행해도 문제가 해결되지 않습니다. 서로 다른 알고리즘은 동일한 작업을 완료하기 위해 서로 다른 시간, 공간 또는 효율성을 사용할 수 있습니다. 알고리즘의 품질은 공간 복잡도와 시간 복잡도로 측정할 수 있습니다.

자바 언어를 사용하여 다양한 알고리즘을 구현할 수 있습니다.

Java의 여러 일반적인 정렬 알고리즘

1. 버블 정렬

자바는 알고리즘인가요? #🎜 🎜#

a. 버블 정렬은 각 순회를 통해 최대/최소값을 얻는 것입니다.

b 최대/최소값을 꼬리/머리에 넣습니다.

#🎜 🎜#c. 그런 다음 최대/최소값을 제외한 나머지 데이터를 순회하여 최대/최소값을 얻습니다.

d, 코드 구현

public static void main(String[] args) {

        int arr[] = {8, 5, 3, 2, 4};

        //冒泡
        for (int i = 0; i < arr.length; i++) {
            //外层循环，遍历次数
            for (int j = 0; j < arr.length - i - 1; j++) {
                //内层循环，升序（如果前一个值比后一个值大，则交换）
                //内层循环一次，获取一个最大值
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }

로그인 후 복사

e, 정렬 프로세스( 빨간색: 이동 중인 데이터 )

5,3,2,4,

8
3,2,4,# 🎜🎜#5, 8
2,3,4,5,8
2,3 ,4,5, 8
2,3,4,5,8
2. 정렬을 선택하세요.

a. 첫 번째 값을 최소값으로 처리합니다

자바는 알고리즘인가요? b 그런 다음 최소값과 아래 첨자를 찾습니다.

c. 이 순회의 시작 값과 최소값을 교환합니다.

d 설명: 각 순회 중에 이전에 찾은 최소값을 순서가 지정된 목록으로 바꿉니다. 순서가 없는 목록을 따라가다가 매번 순서가 없는 목록을 순회하여 최소값을 찾습니다.

e, 코드 구현

public static void main(String[] args) {

        int arr[] = {6, 5, 3, 2, 4};

        //选择
        for (int i = 0; i < arr.length; i++) {
            //默认第一个是最小的。
            int min = arr[i];
            //记录最小的下标
            int index = i;
            //通过与后面的数据进行比较得出，最小值和下标
            for (int j = i + 1; j < arr.length; j++) {
                if (min > arr[j]) {
                    min = arr[j];
                    index = j;
                }
            }
            //然后将最小值与本次循环的，开始值交换
            int temp = arr[i];
            arr[i] = min;
            arr[index] = temp;
            //说明：将i前面的数据看成一个排好的队列，i后面的看成一个无序队列。每次只需要找无需的最小值，做替换
        }
    }

로그인 후 복사

f, 정렬 프로세스(빨간색: 데이터 이동)

2# 🎜 🎜#,5,3,6,4

2,3,5,6,4
2, 3 ,4,6,5
2,3,4,5,6
2, 3 ,4,5,6
3, 삽입 정렬

a, 기본 시작 두 번째 데이터와 비교합니다.

b. 두 번째 데이터가 첫 번째 데이터보다 작으면 교체합니다. 그런 다음 세 번째 데이터와 비교하여 이전 데이터보다 작으면 삽입합니다(교활함). 그렇지 않으면 루프를 종료합니다. 자바는 알고리즘인가요?

c 설명: 기본적으로 첫 번째 데이터는 순서가 지정된 목록으로 간주되며, 다음의 순서가 없는 목록은 이전 데이터보다 작은 경우 반복됩니다. 삽입(교환)됩니다. 그렇지 않으면 종료합니다.

d, 코드 구현

public static void main(String[] args) {

        int arr[] = {7, 5, 3, 2, 4};

        //插入排序
        for (int i = 1; i < arr.length; i++) {
            //外层循环，从第二个开始比较
            for (int j = i; j > 0; j--) {
                //内存循环，与前面排好序的数据比较，如果后面的数据小于前面的则交换
                if (arr[j] < arr[j - 1]) {
                    int temp = arr[j - 1];
                    arr[j - 1] = arr[j];
                    arr[j] = temp;
                } else {
                    //如果不小于，说明插入完毕，退出内层循环
                    break;
                }
            }
        }
    }

로그인 후 복사

e, 정렬 프로세스(빨간색: 순서, 검은색: 순서 없음)

#🎜 🎜# 5,7

,3,2,4

3,5,7
,2,4#🎜 🎜# 2,3,5,7
,4
2,3,4,5,7
#🎜 🎜# 4. 힐 정렬(삽입 정렬의 변형 버전)
a, 기본적으로 삽입 정렬과 동일
#🎜🎜 #b. 차이점은

c를 반으로 나누어 각 주기의 단계 크기를 달성한다는 것입니다. 설명: 기본 원리는 삽입 정렬과 유사하지만 차이점이 있습니다. 여러 데이터에 간격을 두어 삽입 정렬합니다.

d, 코드 구현 자바는 알고리즘인가요?

public static void main(String[] args) {

        int arr[] = {7, 5, 3, 2, 4};

        //希尔排序（插入排序变种版）
        for (int i = arr.length / 2; i > 0; i /= 2) {
            //i层循环控制步长
            for (int j = i; j < arr.length; j++) {
                //j控制无序端的起始位置
                for (int k = j; k > 0  && k - i >= 0; k -= i) {
                    if (arr[k] < arr[k - i]) {
                        int temp = arr[k - i];
                        arr[k - i] = arr[k];
                        arr[k] = temp;
                    } else {
                        break;
                    }
                }
            }
            //j,k为插入排序，不过步长为i
        }
    }

로그인 후 복사

e, 정렬 프로세스(단계 크기 4/2/1)

4,1, 3,2,6,5,8,9,7

3,1,4,2,6,5,7,9,8

1,2, 3,4,5,6,7,8,9

5, 빠른 정렬

a , 목록의 첫 번째 데이터가 중간 값이고 첫 번째 값이 공백으로 간주되는지 확인하십시오(하위 포인터는 공백임).
b 그러면 나머지 큐에는 두 개의 왼쪽 및 오른쪽 포인터(높음 및 낮음)가 있는 것으로 보입니다.

c. 높은 포인터를 시작하여 왼쪽으로 이동합니다. 중간 값보다 작은 데이터가 발견되면 이 데이터를 낮은 포인터 공석에 할당하고 높은 포인터 데이터를 공석 값으로 처리합니다. 높은 포인터 공석) ). 그런 다음 먼저 낮은 포인터를 오른쪽으로 이동하고 낮은 포인터 이동을 전환합니다.

d、当低指针移动到大于中间值的时候，赋值到高指针空缺的地方。然后先高指针向左移动，并且切换高指针移动。重复c、d操作。

e、直到高指针和低指针相等时退出，并且将中间值赋值给对应指针位置。

f、然后将中间值的左右两边看成行的列表，进行快速排序操作。

g、代码实现

public static void main(String[] args) {

        int arr[] = {7, 5, 3, 2, 4, 1, 8, 9, 6};

        //快速排序
        int low = 0;
        int high = arr.length - 1;
        quickSort(arr, low, high);  
    }

    public static void quickSort(int[] arr, int low, int high) {
        //如果指针在同一位置(只有一个数据时)，退出
        if (high - low < 1) {
            return;
        }
        //标记，从高指针开始，还是低指针（默认高指针）
        boolean flag = true;
        //记录指针的其实位置
        int start = low;
        int end = high;
        //默认中间值为低指针的第一个值
        int midValue = arr[low];
        while (true) {
            //高指针移动
            if (flag) {
                //如果列表右方的数据大于中间值，则向左移动
                if (arr[high] > midValue) {
                    high--;
                } else if (arr[high] < midValue) {
                    //如果小于，则覆盖最开始的低指针值，并且移动低指针，标志位改成从低指针开始移动
                    arr[low] = arr[high];
                    low++;
                    flag = false;
                }
            } else {
                //如果低指针数据小于中间值，则低指针向右移动
                if (arr[low] < midValue) {
                    low++;
                } else if (arr[low] > midValue) {
                    //如果低指针的值大于中间值，则覆盖高指针停留时的数据，并向左移动高指针。切换为高指针移动
                    arr[high] = arr[low];
                    high--;
                    flag = true;
                }
            }
            //当两个指针的位置相同时，则找到了中间值的位置，并退出循环
            if (low == high) {
                arr[low] = midValue;
                break;
            }
        }
        //然后出现有，中间值左边的小于中间值。右边的大于中间值。
        //然后在对左右两边的列表在进行快速排序
        quickSort(arr, start, low -1);
        quickSort(arr, low + 1, end);
    }

로그인 후 복사

h、排序过程

6,5,3,2,4,1,7,9,8
1,5,3,2,4,6,7,9,8
1,5,3,2,4,6,7,9,8
1,4,3,2,5,6,7,9,8
1,2,3,4,5,6,7,9,8
1,2,3,4,5,6,7,9,8
1,2,3,4,5,6,7,8,9

6、归并排序

자바는 알고리즘인가요?

a、将列表按照对等的方式进行拆分

b、拆分小最小快的时候，在将最小块按照原来的拆分，进行合并

c、合并的时候，通过左右两块的左边开始比较大小。小的数据放入新的块中

d、说明：简单一点就是先对半拆成最小单位，然后将两半数据合并成一个有序的列表。

e、代码实现

public static void main(String[] args) {

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

        //归并排序
        int start = 0;
        int end = arr.length - 1;
        mergeSort(arr, start, end);
    }

    public static void mergeSort(int[] arr, int start, int end) {
        //判断拆分的不为最小单位
        if (end - start > 0) {
            //再一次拆分，知道拆成一个一个的数据
            mergeSort(arr, start, (start + end) / 2);
            mergeSort(arr, (start + end) / 2 + 1, end);
            //记录开始/结束位置
            int left = start;
            int right = (start + end) / 2 + 1;
            //记录每个小单位的排序结果
            int index = 0;
            int[] result = new int[end - start + 1];
            //如果查分后的两块数据，都还存在
            while (left <= (start + end) / 2 && right <= end) {
                //比较两块数据的大小，然后赋值，并且移动下标
                if (arr[left] <= arr[right]) {
                    result[index] = arr[left];
                    left++;
                } else {
                    result[index] = arr[right];
                    right++;
                }
                //移动单位记录的下标
                index++;
            }
            //当某一块数据不存在了时
            while (left <= (start + end) / 2 || right <= end) {
                //直接赋值到记录下标
                if (left <= (start + end) / 2) {
                    result[index] = arr[left];
                    left++;
                } else {
                    result[index] = arr[right];
                    right++;
                }
                index++;
            }
            //最后将新的数据赋值给原来的列表，并且是对应分块后的下标。
            for (int i = start; i <= end; i++) {
                arr[i] = result[i - start];
            }
        }
    }

로그인 후 복사

f、排序过程