归并排序

归并排序，分治法 import java . util . Arrays ; public class Main_05 { public static final int MAX = 10000 ; /** * 分归并排序，分治法 * @author 1016795105@qq.com * @param args */ public static void main ( String [ ] args ) { int [ ] num = new int [ MAX ] ; for ( int i = 0 ; i < MAX ; i ++ ) { num [ i ] = MAX - i ; } merge_sort ( num , 0 , num . length - 1 ) ; Arrays . stream ( num ) . forEach ( System . out : : println ) ; } //方法入口 public static void merge_sort ( int [ ] num , int left , int right ) { if ( left >= right ) return ; int middle = ( right + left ) / 2 ; merge_sort ( num , left , middle ) ; merge

前言 在此记录一些不太成熟的思考，希望对各位看官有所启发。 从题目可以看出来这篇文章的主题很杂，这篇文章中我主要讨论的是深度学习为什么要“深”这个问题。先给出结论吧：“深”的层次结构是为了应对现实非线性问题中的复杂度，这种“深”的分层结构能够更好地表征图像语音等数据。 好了，如果各位看官感兴趣，那就让我们开始这次思考的旅程吧！ 归并排序 我们首先从归并排序算法开始，这里先跟大家回顾一下这个算法，相信大家都已经非常熟悉了。排序是计算机基础算法中的一个重要主题，要将一个无序的数组排成有序的一个容易想到的算是冒泡法，其时间复杂度为O(n^2)，冒泡算法并没用到“分而治之”的思想，而是一次性地解决问题。而我们要讨论的归并算法的时间复杂度为O(nlogn)，归并算法的大致原理是递归地将待排序的数组分解成更小的数组，将小数组排好序，再逐层将这些排好序的小数组拼成大数组，最终完成排序。直接上代码吧： def merge_sort(arr): """ input : unsorted array output: sorted array in ascending order """ if len(arr) <= 1: return arr half = len(arr)//2 left = merge_sort(arr[0:half]) right = merge_sort(arr[half:])

1 void mergeAdd(int arr[], int left, int mid, int right, int *temp){ 2 　　int i = left; 3 　　int j = mid + 1; 4 　　int k = left;//临时下标 5 　　while (i <= mid&&j <= right){ 6 　　　　if (arr[i] < arr[j]){ 7 　　　　　　temp[k++] = arr[i++]; 8 　　　　}　　 9 　　　　else{ 10 　　　　temp[k++] = arr[j++]; 11 　　　　} 12 　　} 13 　　while (i <= mid){ 14　　 　　temp[k++] = arr[i++]; 15　　 } 16　　 while (j <= right){ 17　　　　 temp[k++] = arr[j++]; 18 　　} 22 　　memcpy(arr + left, temp + left, sizeof(int)*(right - left+1)); 23 } 24 void mergeSort(int arr[],int left,int right,int *temp){ 25　　 int mid = 0; 26 　　if (left < right){ //归并排序采用先分再并的思想

# 归并排序 def merge_sort(list): n = len(list) # 先将待排序的数拆开 if n <= 1: # 拆分到只有一个元素为止，返回。 return list mid = n // 2 # print(list[:mid]) # print(list[mid:]) left_li = merge_sort(list[:mid]) # 归并排序后产生的新有序列表 right_li = merge_sort(list[mid:]) # print(left_li) # print(right_li) # 合并left和right，将2个有序的子序列合并为一个新的整体 left_pointer, right_pointer = 0, 0 # 存放合并后的结果值 result = [] while (left_pointer < len(left_li) and right_pointer <len(right_li) ): if left_li[left_pointer] > right_li[right_pointer]: result.append(right_li[right_pointer]) right_pointer += 1 else: result.append(left_li[left_pointer]) left_pointer +=

归并排序采用分治思想，现将大问题分解成若干个小问题进行递归求解，再将每个小问题的结果合并起来求解大的问题，分而治之 第每一部分的排序复杂度为O(N),深度为logN,所以归并排序的时间复杂度为O(NlogN),最好、最坏、平均时间复杂度都是O(NlogN)。 Java实现： //归并 public void merge(int[] arr, int left, int mid, int right){ int i = left; int j = mid+1; int[] tempArr = new int[right-left+1];//临界数组 int k = 0;//临界数组下标 //将小的数移到临界数组中 while(i<=mid && j<= right){ if(arr[i] < arr[j]){ tempArr[k++] = arr[i++]; }else{ tempArr[k++] = arr[j++]; } } //剩余数据移到临界数组中 while(i <= mid){ tempArr[k++] = arr[i++]; } while(j <= right){ tempArr[k++] = arr[j++]; } //覆盖原来的数组 for(int kk=0; kk<tempArr.length; kk++){ arr[kk+left] = tempArr[kk]

《算法笔记》中摘取 2-路归并排序的非递归写法主要考虑到这一点：每次分组时组内元素个数上线都是2的幂次。于是就可以想到这样的思路：令步长step的初值为2，然后减数组中每个step个元素作为一组，将其内部进行排序（即把左step / 2个元素与右step / 2个元素合并，而若元素个数不超过step / 2，则不操作）；再令step 乘以 2，重复上面的操作，直到step / 2超过元素个数n。 const int maxn = 100; //将数组A的[L1, R1]与[L2, R2]区间合并为有序区间（此处L2记为R1 + 1） void merge(int A[], int L1, int R1, int L2, int R2) { int i = L1, j = L2; //i指向A[L1], j指向A[L2] int temp[maxn], index = 0; //temp临时存放合并后的数组，index为其下标 while(i <= R1 && j <= R2) { if(A[i] <= A[j]) { //如果A[i] <= A[j] temp[index++] = A[i++]; //将A[i]加入序列temp } else { //如果A[i] > A[j] temp[index++] = A[j++];//将A[j]加入序列temp } } while(i <

《算法笔记》中摘取 2-路归并排序的递归写法非常简单，只需要反复将当前区间[left, right]分为两半，对两个子区间[left, mid]与[mid +1, right]分别递归进行归并排序，然后将两个已经有序的合并为有序序列即可。 const int maxn = 100; //将数组A的[L1, R1]与[L2, R2]区间合并为有序区间（此处L2记为R1 + 1） void merge(int A[], int L1, int R1, int L2, int R2) { int i = L1, j = L2; //i指向A[L1], j指向A[L2] int temp[maxn], index = 0; //temp临时存放合并后的数组，index为其下标 while(i <= R1 && j <= R2) { if(A[i] <= A[j]) { //如果A[i] <= A[j] temp[index++] = A[i++]; //将A[i]加入序列temp } else { //如果A[i] > A[j] temp[index++] = A[j++];//将A[j]加入序列temp } } while(i <= R1) temp[index++] = A[i++]; //将[L1, R1]的剩余元素加入序列temp while(j <= R2) temp[index

要了解快慢指针的思想，以及如何实现任意输入，何时停止 #include<stdio.h> #include<stdlib.h> //任意输入，排序并输出 typedef struct Node{ int data; struct Node* next; }LinkNode; //初始链表，使用二级指针,没有头节点 void Init(LinkNode** head){ //使用亚节点 int data=0; LinkNode dummy; LinkNode* pre = NULL; LinkNode* temp = NULL; dummy.next = pre; pre = &dummy; printf("请输入数据："); while(1){ scanf("%d", &data); //把空格从缓冲区读出 temp = (LinkNode *)malloc(sizeof(LinkNode)); temp ->data = data; temp->next = NULL; pre->next = temp; pre = temp; if (getchar()=='\n') { break; } } *head = dummy.next; } void swap(int *a, int *b){ int data = 0; data = *a; *a = *b; *b = data;

package com.maiya; import java.util.Arrays; /** * 排序算法--归并排序法 * 归并排序算法通过递归地平分值列，直至所有的子列都只有一个元素，然后按照次序 * 合并这些子列，从而实现对值列的排序。 * 归并排序算法的一般实现策略为：首先将值列分为大致相同的两个部分，然后递归地 * 对各个子列进行递归分解。重复对值列的递归分解过程，直至满足递归地基本条件， * 即值列按照定义的次序分解为多个只包含一个元素的子列。然后，在控制递归调用结 * 构，该算法将两次递归调用中产生的两个有序子列合并为一个有序子列。 * * @param nums 待排序数组 * @return 输出有序数组 * @author WHF */ public class Sort2 { // 归并排序的实现 public static void main(String[] args) { int[] nums = { 14, 7, 10, 5, 9, 1, 21, 3, 6, 15}; Sort2.sort(nums, 0, nums.length-1); System.out.println(Arrays.toString(nums)); } public static int[] sort(int[] nums, int low, int high) { int

基本思想 　　 归并排序（MERGE-SORT）是利用 归并 的思想实现的排序方法，该算法采用经典的 分治 （divide-and-conquer）策略（分治法将问题 分 (divide) 成一些小的问题然后递归求解，而 治(conquer) 的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。 分而治之 　　 可以看到这种结构很像一棵完全二叉树，本文的归并排序我们采用递归去实现（也可采用迭代的方式去实现）。分阶段可以理解为就是递归拆分子序列的过程，递归深度为log 2 n。 合并相邻有序子序列 　　再来看看 治 阶段，我们需要将两个已经有序的子序列合并成一个有序序列，比如上图中的最后一次合并，要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列，合并为最终序列[1,2,3,4,5,6,7,8]，来看下实现步骤。 代码实现 package sortdemo; import java.util.Arrays; /** * Created by chengxiao on 2016/12/8. */ public class MergeSort { public static void main(String []args){ int []arr = {9,8,7,6,5,4,3,2,1}; sort(arr); System.out.println(Arrays