当前位置:首页 » 爱彩票网 » 正文

分类页和文章页“当前位置”下方广告(PC版)
分类页和文章页“当前位置”下方广告(移动版)

小汽车简笔画,八大排序算法实战:思维与完成,野蛮师姐

353 人参与  2019年05月07日 20:38  分类:爱彩票网  评论:0  
  移步手机端

1、打开你手机的二维码扫描APP
2、扫描左则的二维码
3、点击扫描获得的网址
4、可以在手机端阅读此文章

所谓排序,便是依据排序码的递加或许递减次序把数据元素顺次摆放起来,使一组恣意摆放的元素变为一组按其排序码线性有序的元素。本文将介小汽车简笔画,八大排序算法实战:思想与完结,粗野师姐绍八种最为经典常用的内部排序算法的根本思想与完结,包含刺进排序(直接刺进排序,希尔排序)、挑选排序(直接挑选排序,堆排序)、交奶茶店换排序(冒泡排序,快速排序)、归并排序、分配排序(基数排序),并给出各种算法的时刻复杂度、空间复杂度和安稳性。

本文篇幅较长,文末顺便一些互联网公司java程序员在面试中涉及到的绝大部分架构面试题及答案做成了文档和架构视频材料免费共享给咱们(包含Dubbo、Redis、Netty、zookeeper、Spring cloud、分布式、高并发等架构技能材料)也能够重视取得更多的面试材料,节约咱们搜集的时刻!

一. 排序算法概述

本文将介绍八种最为经典常用的内部排序算法包含刺进排序(直接刺进排序,希尔排序)、挑选排序(直接挑选排序,堆排序)、交流排序(冒泡排序,快速排序)、归并排序、分配排序(基数排序)。实践上,无论是根本排序方法(直接刺进排序,直接挑选小汽车简笔画,八大排序算法实战:思想与完结,粗野师姐排序,冒泡排序),仍是高效排序方法(快速排序,堆排序,归并排序)等,它们各有所长,都具有特定的运用场景。因而,在实践使用中,咱们有必要依据实践使命的特色和各种排序算法的特性来做出最合适的挑选。一般地,咱们衡量一个算法的方针包含:

  1. 时刻复杂度 (在排序进程中需求比较和交流的次数)
  2. 空间复杂度 (在排序进程中需求的辅佐存储空间)
  3. 安稳性 (该算法的完结是否能够确保排序后持平元素的初始次序,只需该算法存在一种完结能够确保这种特征,那么该算法便是安稳的)
  4. 内部排序/外部排序 (在排序进程中数据元素是否彻底在内存)

笔者将在本文侧重讨论上述八种排序算法的思想和完结,并就各算法依据以上方针进行剖析和归类,以便进一步了解它们各自的使用场景。

二. 刺进排序

刺进排序的根本思想:每步将一个待排序元素,按其排序码巨细刺进到前面现已排好序的一组元素中,直到元素悉数刺进停止。在这儿,咱们介绍三种详细的刺进排序算法:直接刺进排序,希尔排序与减半刺进排序。

1、直接刺进排序

直接刺进排序的思想:当刺进第i(i>=1)个元素时,前面的V[0],…,V[i-1]等i-1个 元素现已有序。这时,将第i个元素与前i-1个元素V[i-1],…,V[0]顺次比较,找到刺进方位行将V[i]刺进,一起本来方位上的元素向后顺移。在这儿,刺进方位的查找是次序查找。直接刺进排序是一种安稳的排序算法,其完结如下:

/**
*
* Title: 刺进排序中的直接刺进排序,依赖于初始序列
*
* Description: 在有序序列中不断刺进新的记载以到达扩展有序区到整个数组的意图
*
* 时刻复杂度:最好景象O(n),均匀景象O(n^2),最差景象O(n^2)
*
* 空间复杂度:O(1)
*
* 稳 定 性:安稳
*
* 内部排序(在排序进程中数据元素彻底在内存)
*
*/
public class StraightInsertionSort {
public static int[] insertSort( int[] target )
{
if ( target != null && target.length != 1 ) /* 待排序数组不为空且长度大于1 */
{
for ( int i = 1; i < target.length; i++ ) /* 不断扩展有序序列,直到扩展到整个数组 */
{
for ( int jamy = i; j > 0; j-- ) /* 向有序序列中刺进新的元素 */
{
if ( target[j] < target[j - 1] ) /* 交流 */
{
int temp = target[j];
target[j] = target[j - 1];
target[j - 1] = temp;
}
}
}
}
return(target);
}
}

2、希尔排序

希尔排序的思想:设待排序序列共n个元素,首要取一个整数gap。由于刚开端时,gap较大,每个子序列元素较少,排序速度较快;待到排序后期,gap变小,每个子序列元素较多,但大部分元不老三仙素根本有序,所以排序速度仍较快。一般地,gap取 (gap/3 + 1)。希尔排序是一种不安稳的排序方法,其完结如下:

/**
*
* Title: 刺进排序中的希尔排序,依赖于初始序列
*
* Description: 别离对距离为gap的gap个子序列进行直接刺进排序,不断缩小gap,直至为 1
* 刚开端时,gap较大,每个子序列元素较少,排序速度较快;
*
* 待到排序后期,gap变小,每个子序列元素较多,但大部分元素根本有序,所以排序速度仍较快。
*
* 时刻复杂度:O(n) ~ O(n^2)
*
* 空间复杂度:O(1)
*
* 稳 定 性:不安稳
*
* 内部排序(在排序进程中数据元素彻底在内存)
*/
public class ShellSort {
public static void shellSort( int[] target )
{
if ( target != null && target.length != 1 )
{
int gap = target.length;
while ( gap > 1 ) /* gap为int型,主动取整 */
{
gap = gap / 3 + 1;
for ( int i = gap; i < target.length; i++ )
{
int j = i - gap;
while ( j >= 0 )
{
if ( target[j + ga乌兰巴托p] < target[j] )
{
swap( target, j, j + gap );
j -= gap;
}else{
break;
}
}
}
}
}
}
public static void swap( int[] target, int i, int j )
{
int temp = target[i];
target[i] = target[j];
target[j] = temp;
}
}

3、减半刺进排序

减半刺进排序的思想:当刺进第i(i>=1)个元素时,前面的V[0],…,V[i-1]等i-1个 元素现已有序。这时,减半查找第i个元素在前i-1个元素V[i-1],…,V[0]中的刺进方位,然后直接将V[i]刺进,一起本来方位上的元素向后顺移。与直接刺进排序不同的是,减半刺进排序比直接刺进排序显着减少了关键字之间的比较次数,可是移动次数是没有改动。所以,减半刺进排序和小汽车简笔画,八大排序算法实战:思想与完结,粗野师姐刺进排序的时刻复杂度相同都是O(N^2),但其减少了比较次数,所以该算小汽车简笔画,八大排序算法实战:思想与完结,粗野师姐法依然比直接刺进排序好。减半刺进排序是一种安稳的排序算法,其完结如下:

/**
*
* Title: 刺进排序中的减半刺进排序,依赖于初始序列
*
* Description: 减半查找出刺进方位,并直接刺进;与直接刺进查找的区别是,后者的查找要快于次序查找
*
* 时刻复杂度:减半刺进排序比直接刺进排序显着减少了关键字之间的比较次数,可是移动次数是没有改动。所以,
*
* 减半刺进排序和刺进排序的时刻复杂度相同都是O(N^2),在减少了比较次数方面它的确适当优异,所以该算法依然比直接刺进排序好。
*
* 空间复杂度:O(1)
*
* 稳 定 性:安稳
*
* 内部排序(在排序进程中数据元素彻底在内存)
*
*/
public class BinaryInsertSort {
public static int[] binaryInsertSort( int[] target )
{
if ( target != null && target.length > 1 )
{
for ( int i = 1; i < target.length; i++ )
{
int left = 0;
int right = i - 1;
int mid;
int temp = target[i];
if ( temp < target[right] ) /* 当时值小于有序序列的最大值时,开端查找刺进方位 */
{
while ( left <= right )
{
mid = (left + right) / 2;
if ( target[mid] < temp )
{
left = mid + 1; /* 缩小刺进区间 */
}else if ( target[mid] > temp )
{
right = mid - 1; /* 缩小刺进区间 */
}else{ /* 待刺进值与有序序列中的target[mid]持平,确保安稳性的处理 */
left = left + 1;
}
}
/* left及其后边的数据次序向后移动,并在left方位刺进 */
for ( int j = i; j > left; j-- )
{
target[j] = target[j - 1];
}
target[left] = temp;
}
}
}
return(target);
}
}

三. 挑选排序

挑选排序的根本思想:每一趟 (例如第i趟,i = 0,1,…)在后边第n-i个待排序元素中选出最小元素作为有序序列的第i个元素,直到第n-1趟完毕后,一切元素有序。在这儿,咱们介绍两种详细的挑选排序算法:直接挑选排序与堆排序。

1、直接挑选排序

直接挑选排序的思想:

榜首次从R[0]~R[n-1]中选取最小值,与R[0]交流,第2次从R1~R[n-1]中选取最小值,与R1交流,….,第i次从R[i-1]~R[n-1]中选取最小值,与R[i-1]交流,…..,第n-1次从R[n-2]~R[n-1]中选取最小值,与R[n-2]交流,总共通过n-1次,得到一个按排序码从小到大摆放的有序序列

直接挑选排序是一种不安稳的排序算法,其完结如下:

/**
*
* Title: 挑选排序中的直接挑选排序,依赖于初始序列
*
* Description: 每一趟 (例如第i趟,i = 0,1,...)在后边第n-i个待排序元素中选出最小元素作为有序序列的第i个元素
*
* 时刻复杂度:最好景象O(n^2),均匀景象O(n^2),最差景象O(n^2)
*
* 空间复杂度:O(1)
*
* 稳 定 性:不安稳
*
* 内部排序(在排序进程中数据元素彻底在内存)
*
*/
public class StraightSelectSort {
public static int[] selectSort( int[] target )
{
if ( target != null && target.length != 1 )
{
for ( int i = 0; i < target.length; i++ )
{
int min_index = i;
for ( int j = i + 1; j < target.length; j++ )
{
if ( target[min_index] > target[j] )
{
min_index = j;
}
}
if ( target[min_index] != target[i] ) /* 导致不安稳的要素:交流 6pm*/
{
int min = target[min_index];
target[min_index] = target[i];
target[i] = min;
}
}
}
return(target);
}
}

2、堆排序

堆排序的中心是堆调整算法。首要依据初始输入数据,使用堆调整算法shiftDown()构成初始堆;然后,将堆顶元素与堆尾元素交流,缩小堆的规模并从头调整为堆,如此往复。堆排序是一种不安稳的排序算法,其完结如下:

/**
*
* Title: 堆排序(挑选排序),升序排序(最大堆),依赖于初始序列
*
* Description: 现将给定序列调整为最大堆,然后每次将堆顶元素与堆尾元素交流并缩小堆的规模,直到将堆缩小至1
*
* 时刻复杂度:O(nlgn)
*
* 空间复杂度:O(1)
*
* 稳 定 性:不安稳
*
* 内部排序(在排序进程中数据元素彻底在内存)
*
*/
public class HeapSort {
public stat美人总裁的贴身狂少ic int[] heapSort( int[] target )
{
if ( target != null && target.length > 1 )
{
/* 调整为最大堆 */
int pos = (target.length - 2) / 2;
while ( pos >= 0 )
{
shiftDown( target, pos, target.length - 1 );
pos--;
}
/* 堆排序 */
for ( int i = target.length - 1; i > 0; i-- )
{
int temp = target[i];
target[i] = target[0];
target[0] = temp;
shiftDown( target, 0, i - 1 );
}
return(target);
}
return(target);
}
/**
*
* @description 自上而下调整为最大堆
*
* @author rico
*
* @created 2017年5月25日 上午9:45:40
*
* @param target
*
* @param start
*
* @param end
*
*/
private static void shiftDown( int[] target, int start, int end )
{
int i = start;
int j = 2 * start + 1;
int temp = target[i];
while ( j <= end ) /* 迭代条件 */
{
if ( j < end && target[j + 1] > target[j] ) /* 找出较大子女 */
{
j = j + 1;
}
if ( target[j] <= temp ) /* 父亲大于子女 */
{
break;
} else {
target[i] = target[j];
i = j;
j = 2 * j + 1;
}
}
target[i] = temp;
}
}

四. 交流排序

交流排序的根本思想:依据序列中两个元素的比较成果来对换这两个记载在序列中的方位,也便是说,将键值较大的记载向序列的尾部移动,键值较小的记载向序列的前部移动。

1、冒泡排序

冒泡排序的小汽车简笔画,八大排序算法实战:思想与完结,粗野师姐思想:依据序列中两个元素的比较成果来对换这两个记载在序列中的方位,将键值较大的记载向序列的尾部移动,键值较小的记载向序列的前部移动。因而,每一趟都将较小的元素移到前面,较大的元素天然就逐步沉到终究边了,也便是说,最大的元素终究才干确认,这便是冒泡。冒泡排序是一种安稳的排序算法,其完结如下:

/**
*
* Title: 交流排序中的冒泡排序 ,一般景象下指的是优化后的冒泡排序,最多进行n-1次比较,依赖于初始序列
*
* Description:由于越大的元素会经由交流渐渐"浮"到数列的顶端(终究方位),最大的数终究才确认下来,所以称为冒泡排序
*
* 时刻复杂度:最好景象O(n),均匀景象O(n^2),最差景象O(n^2)
*
* 空cruise间复杂度:O(1)
*
* 稳 定 性:安稳
*
* 内部排序(在排序进程中数据元素彻底在内存)
*
*/
public class BubbleSort {
/**
*
* @description 朴素冒泡排序(共进行n-1次比较)
*
* @author rico
*
*/
public static int[] bubbleSort( int[] target )
{
int n = target.length;
if ( target != null && n != 1 )
{
/* 最多需求进行n-1躺,每一趟将比较小的元素移到前面,比较大的元素天然就逐步沉到终究边了,这便是冒泡 */
for ( int i = 0; i < n - 1; i++ )
{
for ( int j = n - 1; j > i; j-- )
{
if ( target[j] < target[j - 1] )
{
int temp = target[j];
target[j] = target[j - 1];
target[j - 1] = temp;
}
}
System.out.println( Arrays.toString( target ) );
}
}
return(target);
}
/**
*
* @description 优化冒泡排序
*/
public static int[] optimizeBubbleSort( int[] target )
{
int n = target.length;
if ( target != null && n != 1 )
{
/* 最多需求进行n-1躺,每一趟将比较小的元素移到前面,比较大的元素天然就逐步沉到终究边了,这便是冒泡 */
for ( int i = 0; i < n - 1; i++ )
{
boolean exchange = false;
for ( int j = n - 1; j > i; j-- )
{
if ( target[j] < target[j - 1] )
{
int temp = target[j];
target[j] = target[j - 1];
target[j - 1] = temp;
exchange = true;
}
}
System.out.println( Array小汽车简笔画,八大排序算法实战:思想与完结,粗野师姐s.toString( target ) );
if ( !exchange ) /* 若 i 到 n-1 这部分元素现已有序,则直接回来 */
{
return(target);
}
}
}
return(target);
}
}

2、快速排序

快速排序的思想:

通过一趟排序即将排序的数据分割成独立的两部分,其间一部分的一切数据都比别的一部分的一切数据都要小(区分进程),然后再按此方法对这两部分数据别离进行快速排序(快速排序进程),整个排序进程能够递归进行,以此到达整个数据变成有序序列。

快速排序是一种不安稳的排序算法。

/**
*
* Title: 交流排序中的快速排序,现在使用最为广泛的排序算法,是一个递归算法,依赖于初始序列
*
* Description:快速排序包含两个进程:区分 和 快排
*
* "区分"是指将原序列按基准元素区分两个子序列
*
* "快排"是指别离对子序列进行快排
*
* 就均匀核算时刻而言,快速排序是一切内部排序方法中最好的一个
*
* 对大规模数据排序时,快排是快的;对小规模数据排序时,快排是慢的,乃至慢于简略挑选排序等简略排序方法
*
* 快速排序依赖于原始序列,因而其时刻复杂度从O(nlgn)到O(n^2)不等
*
* 时刻复杂度:最好景象O(nlgn),均匀景象O(nlgn),宿最差景象O(n^2)
*
* 递归所耗费的栈空间
*
* 空间复杂度:O(lgn)
*
* 可选任一元素作为基准元素
*
* 稳 定 性:不安稳
*
* 内部排序(在排序进程中数据元素彻底在内存)
*
*/
public class QuickSort {
/**
*
* @description 快排算法(递归算法):在递去进程中就把问题解决了
*
* @param target
*
* @param left
*
* @param right
*
* @修改网return
*
*/
public static int[] quickSort( int[] target, int left, int right )
{
if ( right > left ) /* 递归停止条件 */
{
int base_index = partition( target, left, right ); /* 原序列区分后基准元素的方位 */
quickSort( target, left, base_index - 1 ); /* 对榜首个子序列快速排序,不包含基准元素pineapple! *相似师傅不要啊/
quickSort( target, base_index + 1, right ); /* 对第二个子序列快速排序,不包含基准元素! */
return(target);
}
return(target);
}
/**
*
* @description 序列区分,走错路以榜首个元素为基准元素
*
* @param target 序列
*
* @param left 序列左端
*
* @param right 序列右端
*
* @return
*
*/
public static int partition( int[] target, int left, int right )
{
int base = target[left]; /* 基准元素的值 */
int base_index = left; /* 基准元素终究应该在的方位 */
for ( int i = left + 1; i <= right; i++ ) /* 从基准元素的下一个元素开端 */
{
if ( target[i] < base ) /* 若其小于基准元素 */
{
base_index++; /* 若其小于基准元素,则基准元素终究方位后移;不然不必移动 */
if ( base_index != i ) /* 持平状况意味着i之前的元素都小于base,只需求换一次即可,不需求次次都换 */
{
int temp = target[base_index];
target[base_index] = target[i];
target[i] = temp;
}
}
}
/* 将基准元素就位 */
target[lef1吨等于多少斤t] = target[base_index];
target[base_index] = base;
System.out.println( Arrays.toString( target ) );
return(base_index); /* 回来区分后基准元素的方位 */
}
}

五. 归并排序

归并排序包含两个进程:”归”和”并”。

  • ”归”是指将原序列分红东床序列,别离对子序列进行递归排序;
  • ”并”是指将排好序的各子序列兼并成原序列。

归并排序算法是一个典型的递归算法,因而也是概念上最为简略的排序算法。与快速排序算法比较,归并排序算法不依赖于初始序列,并且是一种安稳的排序算法,但需求与原序列相同巨细的辅佐存储空间。

/**
*
* Title: 归并排序 ,概念上最为简略的排序算法,是一个递归算法 Description:归并排序包含两个进程:归 和 并
*
* "归"是指将原序列分红东床序列,别离对子序列进行递归排序 "并"是指将排流感疫苗好序的各子序列兼并成原序列
*
* 归并排序的首要问题是:需求一个与原待排序数组相同大的辅佐数组空间
*
* 归并排序不依赖于原始序列,因而其最好景象、均匀景象和最差景象时刻复杂度都相同 时刻复杂度:最好景象O(n),均匀景象O(n^2),最差景象O(n^2)
*
* 空间复杂度:O(n) 稳 定 性:安稳 内部排序(在排序进程中数据元素彻底在内存)
*
*/
public class MergeSort {
/**
*
* @description 归并排序算法(递归算法):递去分化,归来兼并
*
* @param target
*
* 待排序序列
*
* @param left
*
* 待排序序列开始方位
*
* @param right
*
* 待排序序列停止方位
*
* @return
*
*/
public static void mergeSort( int[] target )
{
int[] copy = Arrays.copyOf( target, target.length ); /* 空间复杂度O(n) */
mergeSort( target, copy, 0, target.length - 1 );
}
public static void mergeSort( int[] target, int[] copy, int left, int right )
{
if ( right > left ) /* 递归停止条件 */
{
int mid = (left + right) / 2;
mergeSort( target, copy, left, mid ); /* 归并排序榜首个子序列 */
mergeSort( target, copy, mid + 1, right ); /* 归并排序第二个子序列 */
merge( target, copy, left, mid, right ); /* 兼并子序列成原序列 */
}
}
/**
*
* @description 两路归并算法
*
* @param target
*
* 用于存储归并成果
*
* @param left
*
* 榜首个有序表的榜首个元素所在方位
*
* @param mid
*
* 榜首个有序表的终究一个元素所在方位
*
* @param right
*
成瑞龙 * 第二个有序表的终究一个元素所在方位
*
* @return
*
*/
public static void merge( int[] target, int[] copy, int left, int mid,
int right )
{
/* s1,s2是查看指针,index 是寄存指针 */
int s1 = left;
int s2 = mid + 1;
int index = left;
/* 两个表都未查看完,两两比较 */
while ( s1 <= mid && s2 <= right )
{
if ( copy[s1] <= copy[s2] ) /* 安稳性 */
{
target[index++] = copy[s1++];
} else {
target[index++] = copy[s2++];
}
}
/* 若榜首个表未查看完,仿制 */
while ( s1 <= mid )
{
target[index++] = copy[s1++];
}
/* 若第二个表未查看完,仿制 */
while ( s2 <= right )
{
target[index++] = copy[s2++];
}
/* 更新辅佐数组 copy */
for ( int i = left; i <= right; i++ )
{
copy[i] = target[i];
}
}

六. 分配排序(基数排序)

分配排序的根本思想:用空间换时刻。在整个排序进程中,无须比较关键字,而是通过用额定的空间来”分配”和”搜集”来完结排序,它们的时刻复杂度可到达线性阶:O(n)。

基数排序包含两个进程:

  1. 首要,将方针序列各元素分配到各个桶中(分配进程);
  2. 然后,将各个桶中的元素按先进先出的次序再放回去(搜集进程),如此往复,总共需求进行d趟,d为元素的位数。
/**
*
* Title: 分配排序中的基数排序,不依赖于初始序列
*
* Description: 不是在对元素进行比较的基础上进行排序,而是选用 "分配 + 搜集" 的方法
*
*
*
* 首要,将方针序列各元素分配到各个桶中;
*
* 其次,将各个桶中的元素按先进先出的次序再放回去
*
* 如此往复...
*
*
*
* 时刻复杂度:O(d*(r+n)pupupula)或许 O(dn),d 的巨细一般会遭到 n的影响
*
* 空间复杂度:O(rd + n)或许 O(n)
*
* 稳 定 性:安稳
*
* 内部排序(在排序进程中数据元素彻底在内存)
*
*/
public class RadixSort {
/**
*
* @description 分配 + 搜集
*
* @param target 待排序数组
*
* @param r 基数
*
* @param d 元素的位数
*
* @param n 待排序元素个数
*
* @return
*
*/
public static int[] radixSort( int[] target, int r, int d, int n )
{
if ( target != null && target.length != 1 )
{
in7788t[][] bucket = new int[r][n]; /* 总共有基数r个桶,每个桶最多放n个元素靠谱帮手 */
海鱼怎么做好吃 int digit; /* 获取元素对应位上的数字,即装入那个桶 */
int divisor = 1; /* 界说每一轮的除数,1, 10, 100, ... */
int[] count = new int[r]; /* 计算每个桶中实践寄存元素的个数 */
for ( int i = 0; i < d; i++ ) /* d 位的元素,需求通过分配、搜集d次即可完结排序 */
{ /* 分配 */
for ( int ele : target )
{
digit = (ele / divisor) % 10; /* 获取元素对应位上的数字(奇妙!!!) */
bucket[digit][count[digit]++] = ele; /* 将元素放入对应桶,桶中元素数目加1 */
}
/* 搜集 */
int index = 0; /* 方针数组的下标 */
for ( int j = 0; j < r; j++ )
{
int k = 0; /* 用于依照先进先出次序获取桶中元素 */
while ( k < count[j] )
{
target[index++] = bucket[j][k++]; /* 依照先进先出顺次取出桶中的元素 */
}
count[j] = 0; /* 计数器归零 */
}
divisor *= 10; /* 用于获取元素对应位数字 */
}
}
return(target);
}
}

终究给咱们送点免费的东西

资源免费收取,送给需求高清架构脑图,架构视频材料、架构电子书和Java面试文件,以及想要提高技能的朋友。

获取材料的方法:转发+重视+私信小汽车简笔画,八大排序算法实战:思想与完结,粗野师姐【材料】收取!

都看到这儿了,别忘了点个重视哟。以后会继续共享更多干货!!

转载请保留出处和链接!

本文链接:http://www.1688yph.com/articles/68.html

文章底部广告(PC版)
文章底部广告(移动版)
百度分享获取地址:http://share.baidu.com/
百度推荐获取地址:http://tuijian.baidu.com/,百度推荐可能会有一些未知的问题,使用中有任何问题请直接联系百度官方客服!
评论框上方广告(PC版)
评论框上方广告(移动版)
推荐阅读
11月14日

我的世界皮肤,无规矩的开释天分=孩子的没教养,做好三点培育孩子的规矩认识,除夕是几月几日

发布 : | 分类 : 爱彩票网 | 评论 : 0人 | 浏览 : 167次

​泽宝奶奶带着泽宝去玩具屋玩,结果回家的时候生了一肚子的气。“有个四五岁的孩子,特别不像样!泽宝玩什么,他都抢!泽宝的车子他趁我们没注意就给骑走了,连声招呼都没打!...

标签 :