青海餐饮网站建设,杭州百度快照推广,网络安全薪水一般多少,网站建设实务课本目录
一、排序
1.概念
2.常见的排序算法
二、常见排序算法的实现
1.插入排序
1.1直接插入排序
1.2希尔排序(缩小增量法)
1.3直接插入排序和希尔排序的耗时比较
2.选择排序
2.1直接选择排序
2.2堆排序
2.3直接选择排序与堆排序的耗时比较
3.交换排序
3.1冒泡排序…目录
一、排序
1.概念
2.常见的排序算法
二、常见排序算法的实现
1.插入排序
1.1直接插入排序
1.2希尔排序(缩小增量法)
1.3直接插入排序和希尔排序的耗时比较
2.选择排序
2.1直接选择排序
2.2堆排序
2.3直接选择排序与堆排序的耗时比较
3.交换排序
3.1冒泡排序
3.2快速排序
1. Hoare版
2. 挖坑法
3. 前后指针
3.2.1快速排序的优化
1.三数取中法选key
2. 递归到小的子区间时可以考虑使用插入排序
3.2.2非递归的快速排序
4.归并排序
1.归并排序
2.非递归的归并排序
3.海量数据的排序问题
5.排序算法复杂度及稳定性分析
编辑
三、其他非基于比较排序
1.计数排序
2.基数排序
3.桶排序
4.比较
5.排序
一、排序
1.概念
所谓排序就是使一串记录按照其中的某个或某些关键字的大小递增或递减的排列起来的操作。
稳定性假定在待排序的记录序列中存在多个具有相同的关键字的记录若经过排序这些记录的相对次序保持不变即在原序列中r[i]r[j]且r[i]在r[j]之前而在排序后的序列中r[i]仍在r[j]之前则称这种排序算法是稳定的否则称为不稳定的。 内部排序数据元素全部放在内存中的排序
外部排序数据元素太多不能同时放在内存中根据排序过程的要求在内外存之间移动数据的排序
2.常见的排序算法 二、常见排序算法的实现
1.插入排序
把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中直到所有的记录插入完为止得到一个新的有序序列
1.1直接插入排序 public static void insertSort(int[] array) {for (int i 1; i array.length; i) {int j i - 1;int tmp array[i];for (; j 0; j--) {if(array[j] tmp) {
//if(arr[j] tmp)
//变为不稳定的排序array[j1] array[j];}else {
// array[j1] tmp;break;}}array[j1] tmp;}}
直接插入排序的特性总结 1. 元素集合越接近有序直接插入排序算法的时间效率越高 2. 时间复杂度O(N^2) 3. 空间复杂度O(1)它是一种稳定的排序算法 4. 稳定性稳定
如果一个排序 本身就是稳定的排序 那么它就可以被实现为不稳定的排序
但是一个排序 本身就是不稳定的排序 那么它不可能被实现为稳定的排序
1.2希尔排序(缩小增量法)
先选定一个整数把待排序文件分为整数个组再进行每个组内的排序 跳跃式分组: public static void shellSort(int[] array) {int gap array.length;while(gap 1) {gap / 2;shell(array,gap);}}private static void shell(int[] array, int gap) {for (int i gap; i array.length; i) {int j i - gap;int tmp array[i];for (; j 0; j - gap) {if(array[j] tmp) {array[jgap] array[j];}else {break;}}array[jgap] tmp;}} 希尔排序的特性总结 1. 希尔排序是对直接插入排序的优化。 2. 当gap 1时都是预排序目的是让数组更接近于有序。当gap 1时数组已经接近有序的了这样就会很快。这样整体而言可以达到优化的效果。 3. 希尔排序的时间复杂度不固定O(N^1.3)....O(N^1.5) 4. 空间复杂度O(1) 不稳定
1.3直接插入排序和希尔排序的耗时比较
import java.util.Arrays;
import java.util.Random;public class Text {public static void readyDataOrder(int[] array) {Random random new Random();for (int i 0; i array.length; i) {array[i] random.nextInt(100000);}}public static void InsertOrder(int[] array) {array Arrays.copyOf(array,array.length);long start System.currentTimeMillis();Sort.insertSort(array);long end System.currentTimeMillis();System.out.println(插入排序耗时参考 (end - start));}public static void ShellOrder(int[] array) {long start System.currentTimeMillis();Sort.shellSort(array);long end System.currentTimeMillis();System.out.println(希尔排序耗时参考 (end - start));}public static void main(String[] args) {int[] array new int[100000];readyDataOrder(array);InsertOrder(array);ShellOrder(array);}
}
//插入排序耗时参考1884
//希尔排序耗时参考222.选择排序
每一次从待排序的数据元素中选出最小或最大的一个元素存放在序列的起始位置直到全部待排序的数据元素排完
2.1直接选择排序 public static void selectSort(int[] array) {for (int i 0; i array.length; i) {int minIndex i;for (int j i 1; j array.length; j) {if (array[j] array[minIndex]) {minIndex j;}}swap(array,i,minIndex);}}private static void swap(int[] array, int i, int minIndex) {int tmp array[i];array[i] array[minIndex];array[minIndex] tmp;}
直接选择排序的特性总结: 1. 直接选择排序思考非常好理解但是效率不是很好。实际中很少使用 2. 时间复杂度O(N^2) 3. 空间复杂度O(1) 4. 稳定性不稳定
private static void swap(int[] array, int i, int j) {int tmp array[i];array[i] array[j];array[j] tmp;}public static void select2Sort(int[] array) {int left 0;int right array.length - 1;while(leftright) {int minIndex left;int maxIndex left;for (int i left 1; i right; i) {if(array[i] array[minIndex]) {minIndex i;}if(array[i] array[maxIndex]) {maxIndex i;}}swap(array,left,minIndex);//第一个数据是最大值if(maxIndex left) {maxIndex minIndex;}swap(array,right,maxIndex);left;right--;}}
//复杂度不变
2.2堆排序
堆排序(Heapsort)是指利用堆积树堆这种数据结构所设计的一种排序算法它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆排降序建小堆 public static void heapSort(int[] array) {createHeap(array);int end array.length - 1;while(end 0) {swap(array,0,end);siftDown(array,0,end);end--;}}private static void swap(int[] array, int i, int j) {int tmp array[i];array[i] array[j];array[j] tmp;}public static void createHeap(int[] array) {for (int parent (array.length - 1 - 1) / 2; parent 0; parent--) {siftDown(array,parent,array.length);}}private static void siftDown(int[] array,int parent,int len) {int child parent * 2 1;while(child len) {if(child 1 len array[child] array[child 1]) {child;}if(array[child] array[parent]) {swap(array,child,parent);parent child;child parent * 2 1;}else {break;}}}
堆排序的特性总结 1. 堆排序使用堆来选数效率就高了很多。 2. 时间复杂度O(N*logN) 3. 空间复杂度O(1) 4. 稳定性不稳定
2.3直接选择排序与堆排序的耗时比较
public class Text {public static void main(String[] args) {int[] array new int[100000];readyDataOrder(array);InsertOrder(array);ShellOrder(array);selectOrder(array);select2Order(array);heaptOrder(array);}public static void readyDataOrder(int[] array) {Random random new Random();for (int i 0; i array.length; i) {array[i] random.nextInt(100000);}}public static void InsertOrder(int[] array) {array Arrays.copyOf(array,array.length);long start System.currentTimeMillis();Sort.insertSort(array);long end System.currentTimeMillis();System.out.println(插入排序耗时参考 (end - start));}public static void ShellOrder(int[] array) {array Arrays.copyOf(array,array.length);long start System.currentTimeMillis();Sort.shellSort(array);long end System.currentTimeMillis();System.out.println(希尔排序耗时参考 (end - start));}public static void selectOrder(int[] array) {array Arrays.copyOf(array,array.length);long start System.currentTimeMillis();Sort.selectSort(array);long end System.currentTimeMillis();System.out.println(选择排序耗时参考 (end - start));}public static void select2Order(int[] array) {array Arrays.copyOf(array,array.length);long start System.currentTimeMillis();Sort.select2Sort(array);long end System.currentTimeMillis();System.out.println(选择排序2耗时参考 (end - start));}public static void heaptOrder(int[] array) {array Arrays.copyOf(array,array.length);long start System.currentTimeMillis();Sort.heapSort(array);long end System.currentTimeMillis();System.out.println(堆排序耗时参考 (end - start));}
}
//插入排序耗时参考2098
//希尔排序耗时参考25
//选择排序耗时参考4093
//选择排序2耗时参考2929
//堆排序耗时参考16
3.交换排序
所谓交换就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置交换排序的特点是将键值较大的记录向序列的尾部移动键值较小的记录向序列的前部移动。
3.1冒泡排序 public static void bubbleSort(int[] array) {//i是趟数for (int i 0; i array.length - 1; i) {for (int j 0; j array.length - 1 - i; j) {if(array[j] array[j1]) {swap(array,j,j1);}}}}private static void swap(int[] array, int i, int j) {int tmp array[i];array[i] array[j];array[j] tmp;}
冒泡排序的特性总结 1. 冒泡排序是一种非常容易理解的排序 2. 时间复杂度O(N^2) 3. 空间复杂度O(1) 4. 稳定性稳定
优化 public static void bubbleSort(int[] array) {//i是趟数for (int i 0; i array.length - 1; i) {boolean flg true;for (int j 0; j array.length - 1 - i; j) {if(array[j] array[j1]) {swap(array,j,j1);flg false;}}if(flg) {break;}}}private static void swap(int[] array, int i, int j) {int tmp array[i];array[i] array[j];array[j] tmp;}
3.2快速排序
任取待排序元素序列中的某元素作为基准值按照该排序码将待排序集合分割成两子序列左子序列中所有元素均小于基准值右子序列中所有元素均大于基准值然后最左右子序列重复该过程直到所有元素都排列在相应位置上为止
1. Hoare版 public static void quickSort(int[] array) {quick(array,0,array.length - 1);}private static void quick(int[] array, int left, int right) {if(left right) return;int par partition(array,left,right);quick(array,left,par-1);quick(array,par1,right);}private static int partition(int[] array, int start, int end) {int i start;int pivot array[start];while(start end) {
//先end后startwhile(start end array[end] pivot) {end--;}while(start end array[start] pivot) {start;}swap(array,start,end);}swap(array,i,start);return start;}private static void swap(int[] array, int i, int j) {int tmp array[i];array[i] array[j];array[j] tmp;}
快速排序的特性总结 1. 快速排序整体的综合性能和使用场景都是比较好的所以才敢叫快速排序 2. 时间复杂度O(N*logN) 如果的是1 2 3 4 5 或 5 4 3 2 1…… 单分支的树时间复杂度为O(N^2),但一般不说快排时间复杂度为O(N^2) 3. 空间复杂度O(logN) 单分支的树空间复杂度为O(N) 4. 稳定性不稳定 //插入排序耗时参考1983
//希尔排序耗时参考19
//选择排序耗时参考3844
//选择排序2耗时参考2977
//堆排序耗时参考14
//冒泡排序耗时参考20525
//快速排序耗时参考11
2. 挖坑法 public static void quickSort(int[] array) {quick(array,0,array.length - 1);}private static void quick(int[] array, int left, int right) {if(left right) return;int par partition(array,left,right);quick(array,left,par-1);quick(array,par1,right);} private static int partition(int[] array,int start,int end) {int pivot array[start];while(start end) {while(start end array[end] pivot) {end--;}array[start] array[end];while(start end array[start] pivot) {start;}array[end] array[start];}array[start] pivot;return start;}
3. 前后指针 public static void quickSort(int[] array) {quick(array,0,array.length - 1);}private static void quick(int[] array, int left, int right) {if(left right) return;int par partition(array,left,right);quick(array,left,par-1);quick(array,par1,right);}private static int partition(int[] array,int start,int end) {int prev start;int cur start 1;while(cur end) {if(array[cur] array[start] array[prev] ! array[cur]) {swap(array,cur,prev);}cur;}swap(array,prev,start);return prev;}private static void swap(int[] array, int i, int j) {int tmp array[i];array[i] array[j];array[j] tmp;}
3.2.1快速排序的优化
1.三数取中法选key private static void quick(int[] array, int left, int right) {if(left right) return;int index midThreeNum(array,left,right);swap(array,index,left);int par partition(array,left,right);quick(array,left,par-1);quick(array,par1,right);}//三数取中法选keypublic static int midThreeNum(int[] array, int start, int end) {int mid (start end) / 2;if(array[start] array[end]) {if(array[mid] array[start]){return start;}else if(array[mid] array[end]) {return end;}else {return mid;}}else {if(array[mid] array[start]){return start;}else if(array[mid] array[end]) {return end;}else {return mid;}}}
2. 递归到小的子区间时可以考虑使用插入排序 public static void quickSort(int[] array) {quick(array,0,array.length - 1);}private static void quick(int[] array, int left, int right) {if(left right) return;if(right - left 1 7) {insertSort2(array,left,right);}int index midThreeNum(array,left,right);swap(array,index,left);int par partition(array,left,right);quick(array,left,par-1);quick(array,par1,right);}//三数取中法选keypublic static int midThreeNum(int[] array, int start, int end) {int mid (start end) / 2;if(array[start] array[end]) {if(array[mid] array[start]){return start;}else if(array[mid] array[end]) {return end;}else {return mid;}}else {if(array[mid] array[start]){return start;}else if(array[mid] array[end]) {return end;}else {return mid;}}}//递归到小的子区间时可以考虑使用插入排序private static void insertSort2(int[] array ,int start,int end) {for (int i start 1; i end; i) {int j i - 1;int tmp array[i];for (; j start; j--) {if (array[j] tmp) {array[j 1] array[j];} else {
// array[j1] tmp;break;}}array[j 1] tmp;}}private static int partition(int[] array, int start, int end) {int i start;int pivot array[start];while(start end) {while(start end array[end] pivot) {end--;}while(start end array[start] pivot) {start;}swap(array,start,end);}swap(array,i,start);return start;}
3.2.2非递归的快速排序 public static void quickSort2(int[] array) {int left 0;int right array.length - 1;int par partition(array,left,right);StackInteger stack new Stack();if(par left 1) {stack.push(left);stack.push(par - 1);}if(par right - 1) {stack.push(par 1);stack.push(right);}while(!stack.isEmpty()) {right stack.pop();left stack.pop();par partition(array,left,right);if(par left 1) {stack.push(left);stack.push(par - 1);}if(par right - 1) {stack.push(par 1);stack.push(right);}}}private static int partition(int[] array, int start, int end) {int i start;int pivot array[start];while(start end) {while(start end array[end] pivot) {end--;}while(start end array[start] pivot) {start;}swap(array,start,end);}swap(array,i,start);return start;}
4.归并排序
归并排序MERGE-SORT是建立在归并操作上的一种有效的排序算法,该算法是采用分治法Divide andConquer的一个非常典型的应用。将已有序的子序列合并得到完全有序的序列即先使每个子序列有序再使子序列段间有序。若将两个有序表合并成一个有序表称为二路归并
1.归并排序 public static void mergeSort(int[] array) {mergeSortFunc(array,0,array.length - 1);}private static void mergeSortFunc(int[] array,int left,int right) {if(left right) return;int mid (left right) / 2;//分解mergeSortFunc(array,left,mid);mergeSortFunc(array,mid1,right);//合并merge(array,left,right,mid);}private static void merge(int[] array, int left, int right, int mid) {int s1 left;int e1 mid;int s2 mid 1;int e2 right;int[] tmpArr new int[right - left 1];int k 0;while(s1e1 s2e2) {if(array[s1] array[s2]) {tmpArr[k] array[s1];}else {tmpArr[k] array[s2];}}while(s1e1) {tmpArr[k] array[s1];}while(s2e2) {tmpArr[k] array[s2];}for (int i 0; i tmpArr.length; i) {array[ileft] tmpArr[i];}}
归并排序的特性总结 1. 归并的缺点在于需要O(N)的空间复杂度归并排序的思考更多的是解决在磁盘中的外排序问题。 2. 时间复杂度O(N*logN) 3. 空间复杂度O(N) 4. 稳定性稳定
//插入排序耗时参考2301
//希尔排序耗时参考25
//选择排序耗时参考4710
//选择排序2耗时参考3635
//堆排序耗时参考25
//冒泡排序耗时参考23906
//快速排序耗时参考40
//归并排序耗时参考42
2.非递归的归并排序
public static void mergeSort(int[] array) {int gap 1;while (gap array.length) {for (int i 0; i array.length; i 2*gap) {int left i;int mid left gap - 1;int right mid gap;if (mid array.length) {mid array.length - 1;}if (right array.length) {right array.length - 1;}merge(array, left, right, mid);}gap * 2;}}private static void merge(int[] array, int left, int right, int mid) {int s1 left;int e1 mid;int s2 mid 1;int e2 right;int[] tmpArr new int[right - left 1];int k 0;while (s1 e1 s2 e2) {if (array[s1] array[s2]) {tmpArr[k] array[s1];} else {tmpArr[k] array[s2];}}while (s1 e1) {tmpArr[k] array[s1];}while (s2 e2) {tmpArr[k] array[s2];}for (int i 0; i tmpArr.length; i) {array[i left] tmpArr[i];}}
3.海量数据的排序问题
外部排序排序过程需要在磁盘等外部存储进行的排序 前提内存只有 1G需要排序的数据有 100G 因为内存中因为无法把所有数据全部放下所以需要外部排序而归并排序是最常用的外部排序 1. 先把文件切分成 200 份每个 512 M 2. 分别对 512 M 排序因为内存已经可以放的下所以任意排序方式都可以 3. 进行 2路归并同时对 200 份有序文件做归并过程最终结果就有序了
5.排序算法复杂度及稳定性分析 排序方法最好平均最坏空间复杂度稳定性冒泡排序O(n)O(n^2)O(n^2)O(1)稳定插入排序O(n)O(n^2)O(n^2)O(1)稳定选择排序O(n^2)O(n^2)O(n^2)O(1)不稳定希尔排序O(n)O(n^1.3)O(n^2)O(1)不稳定堆排序O(n * log(n))O(n * log(n))O(n * log(n))O(1)不稳定快速排序O(n * log(n))O(n * log(n))O(n^2)O(log(n)) ~ O(n)不稳定归并排序O(n * log(n))O(n * log(n))O(n * log(n))O(n)稳定
三、其他非基于比较排序
1.计数排序
计数排序的场景一定是数据集中在某各范围中
步骤
1. 统计相同元素出现次数 2. 根据统计的结果将序列回收到原来的序列中 public static void countSort(int[] array) {//1.求 最大值 最小值 来确定 计数数组的大小int min array[0];int max array[0];for (int i 1; i array.length; i) {if(array[i] min) {min array[i];}if(array[i] max) {max array[i];}}int len max - min 1;int[] count new int[len];//2.遍历原来的数组 存放元素到计数数组中
//O(N)for (int i 0; i array.length; i) {int index array[i] - min;count[index];}//3.遍历计数数组
//O(范围)int arrIndex 0;for (int i 0; i count.length; i) {while(count[i]!0) {array[arrIndex] i min;arrIndex;count[i]--;}}
时间复杂度O(范围 N )
空间复杂度O(范围)
稳定性稳定
2.基数排序
动态图
队列桶
3.桶排序
划分多个范围相同的区间每个子区间自排序最后合并 public static void bucketSort(int[] array){// 计算最大值与最小值int max array[0];int min array[0];for(int i 1; i array.length; i){if(array[i] min) {min array[i];}if(array[i] max) {max array[i];}}// 计算桶的数量int bucketNum (max - min) / array.length 1;ArrayListArrayListInteger bucketArr new ArrayList(bucketNum);for(int i 0; i bucketNum; i){bucketArr.add(new ArrayListInteger());}// 将每个元素放入桶for(int i 0; i array.length; i){int num (array[i] - min) / (array.length);bucketArr.get(num).add(array[i]);}// 对每个桶进行排序for(int i 0; i bucketArr.size(); i){Collections.sort(bucketArr.get(i));}// 将桶中的元素赋值到原序列int index 0;for(int i 0; i bucketArr.size(); i){for(int j 0; j bucketArr.get(i).size(); j){array[index] bucketArr.get(i).get(j);}}}
4.比较
基数排序根据键值的每位数字来分配桶计数排序每个桶只存储单一键值桶排序每个桶存储一定范围的数值;
5.排序 文章转载自： http://www.morning.cxtbh.cn.gov.cn.cxtbh.cn http://www.morning.lbbgf.cn.gov.cn.lbbgf.cn http://www.morning.ntqnt.cn.gov.cn.ntqnt.cn http://www.morning.mjqms.cn.gov.cn.mjqms.cn http://www.morning.txlnd.cn.gov.cn.txlnd.cn http://www.morning.nccyc.cn.gov.cn.nccyc.cn http://www.morning.qyrnp.cn.gov.cn.qyrnp.cn http://www.morning.hcxhz.cn.gov.cn.hcxhz.cn http://www.morning.zwndt.cn.gov.cn.zwndt.cn http://www.morning.rnnwd.cn.gov.cn.rnnwd.cn http://www.morning.dkmzr.cn.gov.cn.dkmzr.cn http://www.morning.thrcj.cn.gov.cn.thrcj.cn http://www.morning.pflry.cn.gov.cn.pflry.cn http://www.morning.ymqrc.cn.gov.cn.ymqrc.cn http://www.morning.nchsz.cn.gov.cn.nchsz.cn http://www.morning.nmtyx.cn.gov.cn.nmtyx.cn http://www.morning.hwhnx.cn.gov.cn.hwhnx.cn http://www.morning.xclgf.cn.gov.cn.xclgf.cn http://www.morning.knzmb.cn.gov.cn.knzmb.cn http://www.morning.pudejun.com.gov.cn.pudejun.com http://www.morning.nhgkm.cn.gov.cn.nhgkm.cn http://www.morning.phechi.com.gov.cn.phechi.com http://www.morning.wpsfc.cn.gov.cn.wpsfc.cn http://www.morning.rfqk.cn.gov.cn.rfqk.cn http://www.morning.rjnx.cn.gov.cn.rjnx.cn http://www.morning.qqrlz.cn.gov.cn.qqrlz.cn http://www.morning.gwwtm.cn.gov.cn.gwwtm.cn http://www.morning.yjtnc.cn.gov.cn.yjtnc.cn http://www.morning.drkk.cn.gov.cn.drkk.cn http://www.morning.zgdnz.cn.gov.cn.zgdnz.cn http://www.morning.plflq.cn.gov.cn.plflq.cn http://www.morning.chongzhanggui.cn.gov.cn.chongzhanggui.cn http://www.morning.juju8.cn.gov.cn.juju8.cn http://www.morning.qmxsx.cn.gov.cn.qmxsx.cn http://www.morning.pmrlt.cn.gov.cn.pmrlt.cn http://www.morning.gccdr.cn.gov.cn.gccdr.cn http://www.morning.tzkrh.cn.gov.cn.tzkrh.cn http://www.morning.tzkrh.cn.gov.cn.tzkrh.cn http://www.morning.dgmjm.cn.gov.cn.dgmjm.cn http://www.morning.mfsxd.cn.gov.cn.mfsxd.cn http://www.morning.qstkk.cn.gov.cn.qstkk.cn http://www.morning.xtqld.cn.gov.cn.xtqld.cn http://www.morning.hsxkq.cn.gov.cn.hsxkq.cn http://www.morning.rgsgk.cn.gov.cn.rgsgk.cn http://www.morning.nptls.cn.gov.cn.nptls.cn http://www.morning.mxmzl.cn.gov.cn.mxmzl.cn http://www.morning.njddz.cn.gov.cn.njddz.cn http://www.morning.brhxd.cn.gov.cn.brhxd.cn http://www.morning.ljfjm.cn.gov.cn.ljfjm.cn http://www.morning.mnpdy.cn.gov.cn.mnpdy.cn http://www.morning.ypdhl.cn.gov.cn.ypdhl.cn http://www.morning.krbjb.cn.gov.cn.krbjb.cn http://www.morning.fpxsd.cn.gov.cn.fpxsd.cn http://www.morning.snnwx.cn.gov.cn.snnwx.cn http://www.morning.dgfpp.cn.gov.cn.dgfpp.cn http://www.morning.tfqfm.cn.gov.cn.tfqfm.cn http://www.morning.gsksm.cn.gov.cn.gsksm.cn http://www.morning.bgpb.cn.gov.cn.bgpb.cn http://www.morning.gfmpk.cn.gov.cn.gfmpk.cn http://www.morning.ylqrc.cn.gov.cn.ylqrc.cn http://www.morning.hymmq.cn.gov.cn.hymmq.cn http://www.morning.niukaji.com.gov.cn.niukaji.com http://www.morning.kxbdm.cn.gov.cn.kxbdm.cn http://www.morning.trwkz.cn.gov.cn.trwkz.cn http://www.morning.cpzkq.cn.gov.cn.cpzkq.cn http://www.morning.nngq.cn.gov.cn.nngq.cn http://www.morning.gczqt.cn.gov.cn.gczqt.cn http://www.morning.bpmtz.cn.gov.cn.bpmtz.cn http://www.morning.rhmt.cn.gov.cn.rhmt.cn http://www.morning.zhnpj.cn.gov.cn.zhnpj.cn http://www.morning.plfy.cn.gov.cn.plfy.cn http://www.morning.slysg.cn.gov.cn.slysg.cn http://www.morning.nsjpz.cn.gov.cn.nsjpz.cn http://www.morning.qrcxh.cn.gov.cn.qrcxh.cn http://www.morning.fglth.cn.gov.cn.fglth.cn http://www.morning.nsyzm.cn.gov.cn.nsyzm.cn http://www.morning.wgbmj.cn.gov.cn.wgbmj.cn http://www.morning.bqwnp.cn.gov.cn.bqwnp.cn http://www.morning.wqrk.cn.gov.cn.wqrk.cn http://www.morning.sgnjg.cn.gov.cn.sgnjg.cn
