정렬 알고리즘 (버블 정렬, 빠른 정렬)

정렬 알고리즘 교환 정렬 (버블 정렬 및 빠른 정렬)

스왑 정렬 : 시퀀스의 두 요소 키워드 비교 결과에 따라 시퀀스에서 두 레코드의 위치를 ​​바꿉니다.

버블 정렬

원칙은 다음과 같습니다

1. 인접한 요소를 비교하십시오. 첫 번째 것이 두 번째 것보다 크면 두 개를 바꿉니다.

2. 처음의 첫 번째 쌍에서 끝의 마지막 쌍까지 인접한 요소의 각 쌍에 대해 동일하게 수행하십시오. 이 시점에서 마지막 요소가 가장 큰 숫자 여야합니다.

3. 마지막 요소를 제외한 모든 요소에 대해 위의 단계를 반복하십시오.

4. 비교할 숫자 쌍이 없을 때까지 매번 더 적은 수의 요소에 대해 위의 단계를 계속 반복하십시오.

   시간 복잡성이 최고 o (n) 최악 o (n2)

   공간 복잡성 o (1)

   코드 구현 (c)

   #include <stdio.h>
   #include <stdbool.h>
   
   void BubbleSort (int a[],int n){
         
           //冒泡排序 
   	int i,j,temp;         
   	for( i=0;i<n-1;i++){
         
         
   		bool flag=false;      //表示本趟冒泡是否发生交换的标志 
   		for( j=n-1;j>1;j--)   //一趟冒泡的过程 
   		if(a[j-1]>a[j]){
         
               //后面的数小于前面的 进行交换 
   			temp=a[j];
   			a[j]=a[j-1];
   			a[j-1]=temp;
   			flag=true;    
   		}
   		if(flag==false)    //本趟遍历没有发生交换说明结束 
   		return;
   	}
   }
   void Printarr(int a[],int n)    //输出数组 
   {
         
         
   	int i;
   	for(i=0;i<n;i++){
         
         
   		printf("%d",a[i]);
   	}
   	return;
   } 
   
   int main(){
         
                         //主函数 
   	int b,c;
   	int a[]={
         
         1,8,7,5,6};
   	int n=5;
   	printf("未排序的数\n"); 
   	Printarr(a,n);
   	printf("\n");
   	BubbleSort(a,n);
   	printf("冒泡排好序的数\n");
   	Printarr(a,n);
   	return 0;
   }
   

   

빠른 정렬

정렬 할 레코드를 두 개의 독립적 인 부분으로 분리하고 일부 레코드의 키워드는 다른 부분의 키워드보다 작은 다음 레코드의 두 부분을 개별적으로 정렬하여 전체 시퀀스의 순서를 얻을 수 있습니다. .
코드 구현 c

#include <stdio.h>
#include <stdlib.h>

int getStandard(int array[], int i, int j) {
    
    
	//基准数据 
	int key = array[i];
	while (i < j) {
    
     	//因为默认基准是从左边开始，所以从右边开始比较 //当队尾的元素大于等于基准数据 时,就一直向前挪动 j 指针 
			while (i < j && array[j] >= key) {
    
    
				j--;
			}
			if (i < j) {
    
    
				array[i] = array[j];//当找到比 array[i] 小的时，就把后面的值 array[j] 赋给它
			}	
			while (i < j && array[i] <= key) {
    
    //当队首元素小于等于基准数据 时,就一直向后挪动 i 指针 
				i++;
			}
			//当找到比 array[j] 大的时，就把前面的值 array[i] 赋给它
			if (i < j) {
    
    
				array[j] = array[i];
			}
		}
	array[i] = key;//跳出循环时 i 和 j 相等,此时的 i 或 j 就是 key 的正确索引位置
	return i;//把基准数据赋给正确位置 
}
void QuickSort(int array[], int low, int high) {
    
    
	//开始默认基准为 low
	if (low < high) {
    
    
		//分段位置下标 
		int standard = getStandard(array, low, high);
		//递归调用排序
		//左边排序 
		QuickSort(array, low, standard - 1);
		//右边排序 
		QuickSort(array, standard + 1, high);
	}
}

void display(int array[], int size) {
    
    
	int i;
	for (i = 0; i < size; i++) {
    
    
		printf("%d ", array[i]);
	}
	printf("\n");
}

int main() {
    
    
	int array[] = {
    
     49,38,65,97,76,13,27,49,10 };
	int size = sizeof(array) / sizeof(int);
	QuickSort(array, 0, size - 1);
	printf("排好的顺序为") ; 
	display(array, size);
    return 0;
}

시간 복잡도 O (n * 재귀 레이어 수) 공간 복잡도 O (재귀 레이어 수)

최소 레이어 수 (log2n) 최대 n

최적화 된 아이디어 기본 축 요소를 선택할 때 머리, 중간 및 꼬리 사이의 세 가지 비교를 선택하거나 기본 축으로 임의의 숫자를 선택합니다.

시간 복잡도 O (n * 재귀 레이어 수) 공간 복잡도 O (재귀 레이어 수)

최소 레이어 수 (log2n) 최대 n

최적화 된 아이디어 기본 축 요소를 선택할 때 머리, 중간 및 꼬리 사이의 세 가지 비교를 선택하거나 기본 축으로 임의의 숫자를 선택합니다.