C 언어 가 9 대 정렬 알고리즘 을 실현 하 는 실례 코드

직접 삽입 정렬
배열 을 두 부분 으로 나 누 는데 하 나 는 질서 있 는 부분 이 고 하 나 는 무질서 한 부분 이다.무질서 한 부분 에서 순서대로 요 소 를 꺼 내 질서 있 는 부분 에 삽입 합 니 다.과정 은 질서 있 는 부분 을 옮 겨 다 니 며 실현 하 는 것 이 비교적 간단 하 다.

#include <stdio.h>

void insertion_sort(int arr[], int array_length) {
 for (int i = 0; i < array_length; ++i) {
  int data = arr[i];
  int j = 0;
  while (arr[j] < arr[i]) {
   j++;
  }
  for (int k = i; k >= j + 1; k--) {
   arr[k] = arr[k - 1];
  }
  arr[j] = data;
 }
}

void print_array(int arr[], int array_length) {
 for (int i = 0; i < array_length; ++i) {
  printf("%d ", arr[i]);
 }
 printf("
");
}

int main() {
 int arr[7] = {8, 2, 6, 0, 5, 7, 4};
 insertion_sort(arr, 7);
 print_array(arr, 7);
 return 0;
}

반절 기 삽입 정렬
반 으로 접 은 다음 에 직접 삽입 하 는 것 이 개선 되 었 습 니 다.반 으로 접 은 검색 으로 배열 을 교체 하면 배열 의 길이 가 클 때 검색 성능 을 향상 시 킬 수 있 습 니 다.그 본질은 무질서 한 부분 에서 요 소 를 꺼 내 질서 있 는 부분 에 삽입 하 는 것 이다.

#include <stdio.h>

void binary_insertion_sort(int arr[], int array_length) {
 int i, j, low = 0, high = 0, mid;
 int temp = 0;
 for (i = 1; i < array_length; i++) {
  low = 0;
  high = i - 1;
  temp = arr[i];
  while (low <= high) {
   mid = (low + high) / 2;
   if (arr[mid] > temp) {
    high = mid - 1;
   } else {
    low = mid + 1;
   }
  }
  for (j = i; j > low; j--) {
   arr[j] = arr[j - 1];
  }
  arr[low] = temp;
 }
}

void print_array(int arr[], int array_length) {
 for (int i = 0; i < array_length; ++i) {
  printf("%d ", arr[i]);
 }
 printf("
");
}

int main() {
 int brr[5] = {2, 6, 0, 5, 7};
 binary_insertion_sort(brr, 5);
 print_array(brr, 5);
 return 0;
}

힐 정렬
힐 정렬 의 핵심 은 보폭 에 따라 그룹 을 나 누고 그룹 내 에 정렬 을 삽입 하 는 것 이다.보폭 에 대한 선택 은 첫 번 째 보폭 에서 원소 의 개 수 를 취하 고 그 다음 에 매번 원래 보폭 의 절반 을 취한 다.
힐 정렬 은 정렬 을 삽입 하 는 것 에 속한다.

#include <stdio.h>

void shell_sort(int arr[], int array_length) {
 int step = array_length / 2;
 while (step >= 1) {
  for (int i = 0; i < array_length; i += step) {
   int data = arr[i];
   int j = 0;
   while (arr[j] < arr[i]) {
    j++;
   }
   for (int k = i; k >= j + 1; k--) {
    arr[k] = arr[k - 1];
   }
   arr[j] = data;
  }
  step = step / 2;
 }
}

void print_array(int arr[], int array_length) {
 for (int i = 0; i < array_length; ++i) {
  printf("%d ", arr[i]);
 }
 printf("
");
}

int main() {
 int crr[10] = {73, 22, 93, 43, 55, 14, 28, 65, 39, 81};
 shell_sort(crr, 10);
 print_array(crr, 10);
 return 0;
}

거품 정렬
거품 이 일어 나 는 특징 은 두 개의 교환 이다.교환 을 통 해 가장 큰 요 소 를 뒤로 바 꾸 었 고 순환 할 때마다 무질서 한 부분 에서 가장 큰'침'을 뒤로 옮 겼 다.소수 상'부'와 대수 하'침'은 사실 차이 가 없 으 며 모두 거품 을 일 으 킬 수 있다.

#include <stdio.h>

void bubble_sort(int arr[], int array_length) {
 for (int i = 0; i < array_length - 1; ++i) {
  for (int j = 0; j < array_length - i - 1; ++j) {
   if (arr[j] > arr[j + 1]) {
    int temp = arr[j];
    arr[j] = arr[j + 1];
    arr[j + 1] = temp;
   }
  }
 }
}

void print_array(int arr[], int array_length) {
 for (int i = 0; i < array_length; ++i) {
  printf("%d ", arr[i]);
 }
 printf("
");
}

int main() {
 int drr[7] = {8, 2, 6, 0, 5, 7, 4};
 bubble_sort(drr, 7);
 print_array(drr, 7);
 return 0;
}

빠 른 정렬
빠 른 배열 의 정 수 는 하나의 기준(보통 배열 의 첫 번 째 요 소 를 선택 하 는 것)을 선택 한 다음 에 모든 요 소 를 기준 에 따라 두 부분 보다 작 고 큰 부분 으로 나 눈 다음 에 이 두 부분 에서 기준 을 선택 하고 계속 재 귀 하 는 것 이다.최종 정렬 결과 가 전체적으로 질서 가 있다 고 상상 하기 어렵 지 않다.

#include <stdio.h>

int getStandard(int arr[], int low, int high) {
 int flag = arr[low];
 while (low < high) {
  while (low < high && arr[high] >= flag) {
   high--;
  }
  if (low < high) {
   arr[low] = arr[high];
  }
  while (low < high && arr[low] <= flag) {
   low++;
  }
  if (low < high) {
   arr[high] = arr[low];
  }
 }
 arr[low] = flag;
 return low;
}

void quick_sort(int arr[], int low, int high) {
 if (low < high) {
  int pos = getStandard(arr, low, high);
  quick_sort(arr, low, pos - 1);
  quick_sort(arr, pos + 1, high);
 }
}

void print_array(int arr[], int array_length) {
 for (int i = 0; i < array_length; ++i) {
  printf("%d ", arr[i]);
 }
 printf("
");
}

int main() {
 int err[10] = {73, 22, 93, 43, 55, 14, 28, 65, 39, 81};
 quick_sort(err, 0, 9);
 print_array(err, 10);
 return 0;
}

직접 정렬 선택
그 이름 처럼 가장 작은 것 을 직접 선택 하여 맨 앞 에 놓 지만 옮 겨 다 니 면 효율 이 낮은 경우 가 많다.

#include <stdio.h>

void select_sort(int arr[], int array_length) {
 for (int i = 0; i < array_length; ++i) {
  int min_pos = i;
  for (int j = i; j < array_length; ++j) {
   if (arr[min_pos] > arr[j])
    min_pos = j;
  }
  int temp = arr[min_pos];
  arr[min_pos] = arr[i];
  arr[i] = temp;
 }
}

void print_array(int arr[], int array_length) {
 for (int i = 0; i < array_length; ++i) {
  printf("%d ", arr[i]);
 }
 printf("
");
}

int main() {
 int frr[7] = {8, 2, 6, 0, 5, 7, 4};
 select_sort(frr, 7);
 print_array(frr, 7);
 return 0;
}

더미 정렬
배열 을 완전 이 진 트 리 로 변환 합 니 다.임의의 부모 노드 가 그의 하위 노드 보다 크 면 이런 완전 이 진 트 리 를 큰 지붕 더미 라 고 한다.이와 반대로 임의의 부모 노드 가 자식 노드 보다 작 으 면 이런 완전 이 진 트 리 를 작은 지붕 더미 라 고 부른다.
쌓 기 정렬 의 정 수 는 바로 요소 개 수 를 n 으로 하 는 완전 이 진 트 리 를 큰 꼭대기 로 바 꾼 다음 에 쌓 인 지붕 과 마지막 요 소 를 교환 하 는 것 이다.이때 하나의 요소 개 수 를 n-1 로 하 는 완전 이 진 트 리 가 생 긴 다음 에 큰 꼭대기 로 바 꾸 고 쌓 인 지붕 과 마지막 원 소 를 계속 교환 하 는 것 이다.순환 이 반복 되 어 순 서 를 실현 하 였 다.실질 적 으로 정렬 을 선택 합 니 다.매번 가장 큰 것 을 선택 하고 마지막 과 교환 합 니 다.그러나 완전 이 진 트 리 에서 가장 큰 요 소 를 선택 하 는 것 이 배열 을 옮 겨 다 니 는 것 보다 훨씬 빠 릅 니 다.

#include <stdio.h>

void heap_adjust(int arr[], int n) {
 for (int i = n / 2; i >= 1; i--) {
  if (arr[i - 1] < arr[2 * i - 1]) {
   int temp = arr[i - 1];
   arr[i - 1] = arr[2 * i - 1];
   arr[2 * i - 1] = temp;
  }
  if (arr[i - 1] < arr[2 * i] && (2 * i) < n) {
   int temp = arr[i - 1];
   arr[i - 1] = arr[2 * i];
   arr[2 * i] = temp;
  }
 }
}

void heap_sort(int arr[], int array_length) {
 int n = array_length;
 do {
  heap_adjust(arr, n);
  int temp = arr[0];
  arr[0] = arr[n - 1];
  arr[n - 1] = temp;
 } while (n--);
}

void print_array(int arr[], int array_length) {
 for (int i = 0; i < array_length; ++i) {
  printf("%d ", arr[i]);
 }
 printf("
");
}

int main() {
 int grr[7] = {8, 2, 6, 0, 5, 7, 4};
 heap_sort(grr, 7);
 print_array(grr, 7);
 return 0;
}

정렬
병합 의 사상 은 복잡 한 문제 에 대한 분 치 를 최소 길이 로 분산 시 킨 다음 에 합병 작업 을 하 는 것 이다.만약 에 두 개의 배열 A,B 가 있다 고 가정 하면 포인터 i 는 A 의 머리 를 가리 키 고 포인터 j 는 B 의 머리 를 가리 키 며 양쪽 을 동시에 옮 겨 다 니 며 작은 것 을 찾 으 면 배열 안에 넣 고 해당 하 는 지침 에 대응 한 후에 한 자 리 를 옮 기 면 합병 후의 배열 이 질서 가 있다 는 것 을 보증 할 수 있다.

#include <stdio.h>
#include <malloc.h>

void merge(int arr[], int start, int mid, int end) {
 int *new_array = (int *) malloc(sizeof(int) * (end - start + 1));
 int i = start;
 int j = mid + 1;
 int k = 0;
 while (i <= mid && j <= end) {
  if (arr[i] < arr[j]) {
   new_array[k++] = arr[i++];
  } else {
   new_array[k++] = arr[j++];
  }
 }
 while (i <= mid) {
  new_array[k++] = arr[i++];
 }
 while (j <= end) {
  new_array[k++] = arr[j++];
 }
 for (int l = 0; l < k; ++l) {
  arr[start + l] = new_array[l];
 }
 free(new_array);
}

void merge_sort(int arr[], int start, int end) {
 int mid = (start + end) / 2;
 if (start >= end) {
  return;
 }
 merge_sort(arr, start, mid);
 merge_sort(arr, mid + 1, end);
 merge(arr, start, mid, end);
}

void print_array(int arr[], int array_length) {
 for (int i = 0; i < array_length; ++i) {
  printf("%d ", arr[i]);
 }
 printf("
");
}

int main() {
 int hrr[10] = {73, 22, 93, 43, 55, 14, 28, 65, 39, 81};
 merge_sort(hrr, 0, 9);
 print_array(hrr, 10);
 return 0;
}

기수 정렬
먼저 한 자리 순서에 따라 모든 숫자 를 0-9 이 10 개의 통 안에 분배 한 다음 에 통 의 순서에 따라 수집한다.10 위 순 으로 똑 같은 절차 로...
기본 정렬 의 본질은 모든 사람 을 정렬 하 는 것 이다.모든 사람 을 정렬 한 후에 이 수의 전체적인 크기 가 순서대로 배열 되 는 것 을 보장 할 수 있다.

#include <stdio.h>
#include <malloc.h>

int get_num(int number, int pos) {
 int num = 0;
 while (pos--) {
  num = number % 10;
  number = number / 10;
 }
 return num;
}

void radix_sort(int arr[], int array_length) {
 int *bucket[10];
 for (int i = 0; i < 10; ++i) {
  bucket[i] = (int *) malloc(sizeof(int) * array_length + 1);
  bucket[i][0] = 0;//             
 }
 for (int b = 1; b <= 31; ++b) {
  for (int i = 0; i < array_length; ++i) {
   int num = get_num(arr[i], b);//         （  、  、  ...）
   int index = ++bucket[num][0];//    
   bucket[num][index] = arr[i];//     
  }
  for (int i = 0, k = 0; i < 10; i++) {
   for (int j = 1; j <= bucket[i][0]; ++j) {
    arr[k++] = bucket[i][j];//          
   }
   bucket[i][0] = 0;//    
  }
 }
}

void print_array(int arr[], int array_length) {
 for (int i = 0; i < array_length; ++i) {
  printf("%d ", arr[i]);
 }
 printf("
");
}

int main() {
 int irr[10] = {73, 22, 93, 43, 55, 14, 28, 65, 39, 81};
 radix_sort(irr, 10);
 print_array(irr, 10);
 return 0;
}

총결산
여기 서 C 언어 가 9 대 정렬 알고리즘 을 실현 하 는 것 에 관 한 이 글 은 여기까지 소개 되 었 습 니 다.더 많은 C 언어 9 대 정렬 알고리즘 내용 은 우리 의 이전 글 을 검색 하거나 아래 의 관련 글 을 계속 조회 하 시기 바 랍 니 다.앞으로 저 희 를 많이 사랑 해 주세요!