C #은 버블 정렬, 선택 정렬, 빠른 정렬을 실현합니다. C # 학습 기타 (6)

1. 버블 정렬

버블 정렬은 순회 할 때마다 정렬되지 않은 부분에서 가장 큰 요소가 끝에 놓이는 것을 의미하며, N-1 회 순회하면 모든 요소가 작은 것에서 큰 것으로 정렬됩니다.

 			int[] array = {
    
     8, 7, 1, 5, 2, 3 };
            for (int j = 0; j < array.Length-1; j++)//j表示冒泡次数，即遍历数组的次数
            {
    
    
                //遍历数组
                for (int i = 0; i < array.Length - 1-j; i++) //内层循环索引随之递减
                {
    
    
                    if (array[i] > array[i + 1])//如果当前元素比后面一个元素大,就交换位置
                    {
    
    
                        int temp = array[i];
                        array[i] = array[i + 1];
                        array[i + 1] = temp;
                    }
                }
            }

2. 정렬 선택

선택적 정렬이란 정렬되지 않은 부분을 순회 할 때마다 가장 작은 요소가 끝에 놓이는 것을 의미합니다. N-1 회 순회하면 모든 요소가 가장 작은 요소에서 가장 큰 요소로 정렬됩니다.

 			int[] array = {
    
     8, 7, 1, 5, 2, 3 };
            for (int i= 0; i < array.Length-1; i++)
            {
    
    
                int mIndex = i;//暂且认为 i 位置就是最小的元素
                for (int j = i+ 1; j < array.Length; j++)//找出最小的元素
                {
    
    
                    if (array[j] < array[mIndex])
                    {
    
    
                        mIndex = i;
                    }
                }
                //将最小元素与 i 位置元素交换
                int temp = array[i];
                array[i] = array[mIndex];
                array[mIndex] = temp;
            }

3. 빠른 정렬

빠른 정렬은 일반적으로 데이터가 매우 클 때 사용되며 효율성은 처음 두 방법보다 훨씬 높습니다.

void sort(int[] arr, int min, int max)
        {
    
    
            int key = arr[min];//基准数
            int start = min;//开始位置
            int end = max;//结束位置

            while (end > start)
            {
    
    
                //从后往前找，比基准数小的元素
                while (end > start && arr[end] >= key)
                {
    
    
                    end--;
                }
                if (arr[end] < key)//找到后，将start与end位置元素交换
                {
    
    
                    int temp = arr[end];
                    arr[end] = arr[start];
                    arr[start] = temp;
                }
                //从前往后找，比基准数大的元素
                while (end > start && arr[start] <= key)
                {
    
    
                    start++;
                }
                if (arr[start] > key)//找到后，将start与end位置元素交换
                {
    
    
                    int temp = arr[end];
                    arr[end] = arr[start];
                    arr[start] = temp;
                }
            }
            if (start > min)//如果未排序完成，则通过递归，再次排序
            {
    
    
                sort(arr, min, start - 1);
            }
            if (end < max)
            {
    
    
                sort(arr, end + 1, max);
            }
        }