归并排序和直接插入排序
时间: 2023-10-15 13:26:32 浏览: 49
归并排序和直接插入排序是两种常见的排序算法。
归并排序(Merge Sort)是一种分治策略的排序算法。它将待排序的序列不断地二分,直到只剩下一个元素,然后再将这些单个元素合并成有序的序列。具体步骤如下:
1. 将待排序序列不断地二分,直到每个子序列只剩下一个元素。
2. 将相邻的两个子序列两两合并,使得合并后的子序列有序。
3. 不断重复步骤2,直到最终只剩下一个有序序列。
直接插入排序(Insertion Sort)是一种简单直观的排序算法。它通过构建有序序列,对于未排序的元素,在已排序序列中从后向前扫描,找到相应位置并插入。具体步骤如下:
1. 将第一个元素视为已排序序列。
2. 从第二个元素开始,逐个将未排序的元素插入到已排序序列中的正确位置。
3. 重复步骤2,直到所有元素都被插入到有序序列中。
归并排序的时间复杂度为O(nlogn),空间复杂度为O(n)。它具有稳定性和适用于大规模数据排序的优点。
直接插入排序的时间复杂度为O(n^2),空间复杂度为O(1)。它具有简单易懂、适用于小规模数据排序的优点。
这是关于归并排序和直接插入排序的简要介绍,希望能对你有所帮助!如果你还有其他问题,请随时提问。
相关问题
冒泡排序,归并排序,希尔排序,冒泡排序的改进版,基数排序,折半插入排序,插入排序和直接插入排序C语言代码实现
以下是各种排序算法在C语言中的代码实现:
1. 冒泡排序:
```c
void bubbleSort(int arr[], int n) {
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
```
2. 归并排序:
```c
void merge(int arr[], int left, int mid, int right) {
int i, j, k;
int n1 = mid - left + 1;
int n2 = right - mid;
int L[n1], R[n2];
for (i = 0; i < n1; i++)
L[i] = arr[left + i];
for (j = 0; j < n2; j++)
R[j] = arr[mid + 1 + j];
i = 0;
j = 0;
k = left;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
void mergeSort(int arr[], int left, int right) {
if (left < right) {
int mid = left + (right - left) / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
merge(arr, left, mid, right);
}
}
```
3. 希尔排序:
```c
void shellSort(int arr[], int n) {
for (int gap = n / 2; gap > 0; gap /= 2) {
for (int i = gap; i < n; i++) {
int temp = arr[i];
int j;
for (j = i; j >= gap && arr[j - gap] > temp; j -= gap)
arr[j] = arr[j - gap];
arr[j] = temp;
}
}
}
```
4. 冒泡排序的改进版:
```c
void optimizedBubbleSort(int arr[], int n) {
for (int i = 0; i < n - 1; i++) {
bool swapped = false;
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
swapped = true;
}
}
if (!swapped)
break;
}
}
```
5. 基数排序:
```c
int getMax(int arr[], int n) {
int max = arr[0];
for (int i = 1; i < n; i++) {
if (arr[i] > max)
max = arr[i];
}
return max;
}
void countSort(int arr[], int n, int exp) {
int output[n];
int count[10] = {0};
for (int i = 0; i < n; i++)
count[(arr[i] / exp) % 10]++;
for (int i = 1; i < 10; i++)
count[i] += count[i - 1];
for (int i = n - 1; i >= 0; i--) {
output[count[(arr[i] / exp) % 10] - 1] = arr[i];
count[(arr[i] / exp) % 10]--;
}
for (int i = 0; i < n; i++)
arr[i] = output[i];
}
void radixSort(int arr[], int n) {
int max = getMax(arr, n);
for (int exp = 1; max / exp > 0; exp *= 10)
countSort(arr, n, exp);
}
```
6. 折半插入排序:
```c
void binaryInsertionSort(int arr[], int n) {
for (int i = 1; i < n; i++) {
int key = arr[i];
int left = 0;
int right = i - 1;
while (left <= right) {
int mid = (left + right) / 2;
if (arr[mid] > key)
right = mid - 1;
else
left = mid + 1;
}
for (int j = i - 1; j >= left; j--)
arr[j + 1] = arr[j];
arr[left] = key;
}
}
```
7. 插入排序:
```c
void insertionSort(int arr[], int n) {
for (int i = 1; i < n; i++) {
int key = arr[i];
int j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
}
```
8. 直接插入排序:
```c
void straightInsertionSort(int arr[], int n) {
for (int i = 1; i < n; i++) {
if (arr[i] < arr[i - 1]) {
int temp = arr[i];
int j;
for (j = i - 1; j >= 0 && arr[j] > temp; j--) {
arr[j + 1] = arr[j];
}
arr[j + 1] = temp;
}
}
}
```
以上是各种排序算法在C语言中的实现代码,你可以根据需要选择使用。
直接插入排序,折半插入排序,希尔排序,冒泡排序,快速排序,简单选择排序,归并排序
以下是七种排序算法的介绍和示例:
1. 直接插入排序(Insertion Sort):
直接插入排序是一种简单直观的排序算法,它的基本思想是将待排序的元素按照大小插入到已排序的序列中的适当位置。具体步骤如下:
```python
def insertion_sort(arr):
for i in range(1, len(arr)):
key = arr[i]
j = i - 1
while j >= 0 and arr[j] > key:
arr[j + 1] = arr[j]
j -= 1
arr[j + 1] = key
arr = [5, 2, 8, 12, 7]
insertion_sort(arr)
print(arr) # 输出:[2, 5, 7, 8, 12]
```
2. 折半插入排序(Binary Insertion Sort):
折半插入排序是对直接插入排序的一种改进,它通过使用二分查找来减少比较次数。具体步骤如下:
```python
def binary_insertion_sort(arr):
for i in range(1, len(arr)):
key = arr[i]
left = 0
right = i - 1
while left <= right:
mid = (left + right) // 2
if arr[mid] > key:
right = mid - 1
else:
left = mid + 1
for j in range(i - 1, left - 1, -1):
arr[j + 1] = arr[j]
arr[left] = key
arr = [5, 2, 8, 12, 7]
binary_insertion_sort(arr)
print(arr) # 输出:[2, 5, 7, 8, 12]
```
3. 希尔排序(Shell Sort):
希尔排序是一种插入排序的改进算法,它通过将待排序的序列分割成若干个子序列,对子序列进行插入排序,最后再对整个序列进行一次插入排序。具体步骤如下:
```python
def shell_sort(arr):
n = len(arr)
gap = n // 2
while gap > 0:
for i in range(gap, n):
temp = arr[i]
j = i
while j >= gap and arr[j - gap] > temp:
arr[j] = arr[j - gap]
j -= gap
arr[j] = temp
gap //= 2
arr = [5, 2, 8, 12, 7]
shell_sort(arr)
print(arr) # 输出:[2, 5, 7, 8, 12]
```
4. 冒泡排序(Bubble Sort):
冒泡排序是一种简单的排序算法,它重复地遍历待排序的序列,每次比较相邻的两个元素,如果顺序错误就交换它们,直到没有需要交换的元素为止。具体步骤如下:
```python
def bubble_sort(arr):
n = len(arr)
for i in range(n - 1):
for j in range(n - 1 - i):
if arr[j] > arr[j + 1]:
arr[j], arr[j + 1] = arr[j + 1], arr[j]
arr = [5, 2, 8, 12, 7]
bubble_sort(arr)
print(arr) # 输出:[2, 5, 7, 8, 12]
```
5. 快速排序(Quick Sort):
快速排序是一种高效的排序算法,它通过选择一个基准元素,将序列分割成两部分,一部分小于基准元素,一部分大于基准元素,然后对两部分递归地进行快速排序。具体步骤如下:
```python
def quick_sort(arr):
if len(arr) <= 1:
return arr
pivot = arr[len(arr) // 2]
left = [x for x in arr if x < pivot]
middle = [x for x in arr if x == pivot]
right = [x for x in arr if x > pivot]
return quick_sort(left) + middle + quick_sort(right)
arr = [5, 2, 8, 12, 7]
arr = quick_sort(arr)
print(arr) # 输出:[2, 5, 7, 8, 12]
```
6. 简单选择排序(Selection Sort):
简单选择排序是一种简单直观的排序算法,它的基本思想是每次从待排序的序列中选择最小(或最大)的元素,放到已排序序列的末尾。具体步骤如下:
```python
def selection_sort(arr):
n = len(arr)
for i in range(n - 1):
min_index = i
for j in range(i + 1, n):
if arr[j] < arr[min_index]:
min_index = j
arr[i], arr[min_index] = arr[min_index], arr[i]
arr = [5, 2, 8, 12, 7]
selection_sort(arr)
print(arr) # 输出:[2, 5, 7, 8, 12]
```
7. 归并排序(Merge Sort):
归并排序是一种分治算法,它将待排序的序列分成两个子序列,对每个子序列进行递归地归并排序,然后将两个有序的子序列合并成一个有序的序列。具体步骤如下:
```python
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr) // 2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
return merge(left, right)
def merge(left, right):
result = []
i = j = 0
while i < len(left) and j < len(right):
if left[i] < right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1
result.extend(left[i:])
result.extend(right[j:])
return result
arr = [5, 2, 8, 12, 7]
arr = merge_sort(arr)
print(arr) # 输出:[2, 5, 7, 8, 12]
```