数据结构-次序表

主道杀神

文章目次

1、挨次表的观点
        1.挨次存储观点
2、挨次表的完成
        1.静态挨次表的完成
                (1).静态挨次表的观点
                (2). 静态挨次表的构造体界说
                (3).静态挨次表初初化
                (4).静态挨次表获得元素
                (5).静态挨次表的插进操纵
                (6).静态挨次表的删除操纵
                (7).静态挨次表的改动元素操纵
                (8).挨印静态挨次表的元素
                (9).总代码
              (10).征象

        2.静态挨次表的完成
                (1).静态挨次表的观点
                (2).静态挨次表的空间断定
                (3). 静态挨次表的构造体界说
                (4).静态挨次表初初化
                (5).静态挨次表获得元素
                (6).静态挨次表的插进操纵
                (7).静态挨次表的删除操纵
                (8).静态挨次表的改动元素操纵
                (9).挨印静态挨次表的元素
              (10).总代码
              (11).征象
        3.挨次表的劣缺陷
               (1).长处
               (2).缺陷

---

1、挨次表的观点
1.挨次存储观点
        挨次存储构造，是指用一段地点持续的存储单位顺次存储线性表的数据元素。
2.存储方法
       正在编程言语中，用一维数组去完成挨次存储，正在c言语中，把第一个数据元素存储到下标为0的地位中,把第两个数据元素存储到下标为1的地位中,把第三个数据元素存储到下标为2的地位中,以此类推。
3.少度战容量
       数组的少度指的是数组当前有几个元素，数组的容量指的是最年夜能够大要寄存几个元素。假设数组元素年夜于最年夜能存储。假设数组少度年夜于最年夜能存储的范畴,正在法式上是没有许可的,能够会段毛病，招致法式间接瓦解，完成上需求躲避的。
2、挨次表的完成
1.静态挨次表
（1）静态挨次表观点
        静态挨次挨次表的观点便是，挨次表的数组容量是牢固不变的，当挨次表的数组谦了，便不克不及再存储元素了。
（2）静态挨次表的构造体界说

1. #define MAXSIZE 20             /*存储空间的初初分派量*/
2. typedef int ElemType;                   /*ElemType范例按照实践状况而定,那里为int*/
3. typedef struct sqlist               
4. {
5.         ElemType data[MAXSIZE];   /*数组,存储数据元素*/
6.         int length;                                   /*线性表当前少度*/
7. }sqlist;
9. #define OK 1
10. #define ERROR 0
11. typedef int Status;  /*Status是函数的范例,其值是函数成果形态代码,如OK等*/

复造代码

        ·（1）数据范例为Elemtype,界说为int;
        ·（2）sqlist界说的便是一个最多寄存MAXSIZE元素的数组,MAXSIZE代表数组容量;
        ·  (3) length代表数组少度,即当前的元素个数;
        · (4) Status代表函数的范例。
(3)静态挨次表初初化

1. /*函数功用:挨次表初初化*/                           
2. /*初初前提:无*/
3. /*操纵成果:无*/
4. sqlist* listinit()
5. {
6.         sqlist *L=(sqlist* )malloc(sizeof(struct sqlist));
7.         bzero(L->data,MAXSIZE);
8.         L->length=0;
9.         return L;
10. }

复造代码

   留意:此处返回的范例是挨次表构造体指针。
（4）静态挨次表获得元素

1. /*函数功用:获得元素*/
2. /*初初前提:挨次线性表L已存正在,1<=i<listlength(L)*/
3. /*操纵成果:用e返回L中第i个元素的值,留意i指的是地位,第一个地位的数组是从0开端*/
4. Status getELem(sqlist* L, int i, ElemType *e)
5. {
6.         if(L->length==0 || i<1 || i>L->length)
7.                 return ERROR;
8.         *e=L->data[i-1];
9.        
10.         return OK;
11. }

复造代码

            ·（1）L是挨次表的构造体指针;
            ·（2）i是您要得到的第几个元素的地位，留意i指的是地位,第一个地位的数组是从0开端;
            ·  (3) e是元素指针，将获得的元素赋值给e指背的变量。
（5）静态挨次表的插进操纵

1. /*函数功用:插进操纵*/
2. /*初初前提:挨次线性表L已存正在,1<=i<listlength(L)*/
3. /*操纵成果:正在L中第i个地位之前插进新的数据元素e,L的少度减1*/
4. Status ListInsert(sqlist *L, int i, ElemType e)
5. {
6.         int k;
7.         if(L->length==MAXSIZE)             /*挨次表已谦*/
8.                 return ERROR;
9.         if(i<1 || i>L->length+1)                   /*当i比第一名置小大概比最初一名后一名置借要年夜的时分*/
10.         {
11.                 return ERROR;                                   /*假如插进地位没有正在表尾*/
12.         }
13.        
14.         if(i<=L->length)
15.         {
16.                 for(k=L->length-1; k>=i; k--)        /*将要插进地位后的元素,背后移一名*/
17.                 {
18.                         L->data[k+1]=L->data[k];    /*将新元素插进*/
19.                 }
20.         }
21.         L->data[i-1]=e;
22.         L->length++;   
23.        
24.         return OK;
25. }

复造代码

        ·（1）L是挨次表的构造体指针;
       · （2）i是您要插进的地位，那里i的指的地位取上里的一样;
       · （3）e是您要插进的元素。
（6）静态挨次表的删除操纵

1. /*函数功用:删除元素*/
2. /*初初前提:挨次线性表L已存正在,1<=i<listlength(L)*/
3. /*操纵成果:删除L的第i个数据元素,并用e返回其值,L的少度睹加1*/
4. Status         ListDelete(sqlist *L, int i, ElemType *e)
5. {
6.         int k;
7.         if(L->length==0)                                         /*线性表为空*/
8.                 return ERROR;                                       
9.         if(i<1 || i>L->length)                                /*删除地位禁绝确*/
10.                 return ERROR;
11.         *e=L->data[i-1];
12.         if(i<L->length)                                                /*假如删除没有是最初的地位*/
13.         {
14.                 for(k=i; k<L->length; k++)                /*将删除地位后继元素前移*/
15.                 {
16.                         L->data[k-1]=L->data[k];
17.                 }
18.         }
19.        
20.         L->length--;
21.         return OK;
22. }

复造代码

        ·（1）L是挨次表的构造体指针;
        · （2）i是您要删除的地位，那里i的指的地位取上里的一样;
        ·  (3) e是元素指针，将获得的元素赋值给e指背的变量。
（7）静态挨次表的改动元素操纵

1. //函数功用:改动元素
2. //初初前提:无
3. //操纵成果:将间接改动对应元素的值
4. Status ListChange(sqlist* L, ElemType oldnum, ElemType newnum)
5. {
6.         int k=0;
7.         for(k=0; k<L->length; k++)   //遍历找到要修正的元素oldnum,
8.         {
9.                 if(L->data[k]==oldnum)
10.                 {
11.                         L->data[k]=newnum;   //将oldnum交换为newnum
12.                         return OK;
13.                 }
14.         }
15.         return ERROR;
16. }

复造代码

        ·（1）L是挨次表的构造体指针;
        ·（2）oldnum是本来的元素；
        ·（3）newnum是新的元素。
（8）挨印静态挨次表的元素

1. //此函数只合用于元素范例为int
2. //函数功用:遍历挨次表
3. //初初前提:挨次表没有为空;
4. //操纵成果:挨印出线性表
5. void listprintf(sqlist *L)
6. {
7.         int k=0;
8.         for(k=0; k<L->length; k++)
9.         {
10.                 printf("第%d个元素: %d\n", k, L->data[k]);
11.         }
12. }

复造代码

        留意:此函数只合适元素范例为int
     ·（1）L是挨次表的构造体指针;
（9）总代码

1. #include "stdio.h"#include #include //构造体界说#define MAXSIZE 20             /*存储空间的初初分派量*/
2. typedef int ElemType;                   /*ElemType范例按照实践状况而定,那里为int*/
3. typedef struct sqlist               
4. {
5.         ElemType data[MAXSIZE];   /*数组,存储数据元素*/
6.         int length;                                   /*线性表当前少度*/
7. }sqlist;
9. #define OK 1
10. #define ERROR 0
11. typedef int Status;  /*Status是函数的范例,其值是函数成果形态代码,如OK等*//*函数功用:挨次表初初化*/                           
12. /*初初前提:无*/
13. /*操纵成果:无*/
14. sqlist* listinit()
15. {
16.         sqlist *L=(sqlist* )malloc(sizeof(struct sqlist));
17.         bzero(L->data,MAXSIZE);
18.         L->length=0;
19.         return L;
20. }/*函数功用:获得元素*/
21. /*初初前提:挨次线性表L已存正在,1<=i<listlength(L)*/
22. /*操纵成果:用e返回L中第i个元素的值,留意i指的是地位,第一个地位的数组是从0开端*/
23. Status getELem(sqlist* L, int i, ElemType *e)
24. {
25.         if(L->length==0 || i<1 || i>L->length)
26.                 return ERROR;
27.         *e=L->data[i-1];
28.        
29.         return OK;
30. }/*函数功用:插进操纵*/
31. /*初初前提:挨次线性表L已存正在,1<=i<listlength(L)*/
32. /*操纵成果:正在L中第i个地位之前插进新的数据元素e,L的少度减1*/
33. Status ListInsert(sqlist *L, int i, ElemType e)
34. {
35.         int k;
36.         if(L->length==MAXSIZE)             /*挨次表已谦*/
37.                 return ERROR;
38.         if(i<1 || i>L->length+1)                   /*当i比第一名置小大概比最初一名后一名置借要年夜的时分*/
39.         {
40.                 return ERROR;                                   /*假如插进地位没有正在表尾*/
41.         }
42.        
43.         if(i<=L->length)
44.         {
45.                 for(k=L->length-1; k>=i; k--)        /*将要插进地位后的元素,背后移一名*/
46.                 {
47.                         L->data[k+1]=L->data[k];    /*将新元素插进*/
48.                 }
49.         }
50.         L->data[i-1]=e;
51.         L->length++;   
52.        
53.         return OK;
54. }/*函数功用:删除元素*/
55. /*初初前提:挨次线性表L已存正在,1<=i<listlength(L)*/
56. /*操纵成果:删除L的第i个数据元素,并用e返回其值,L的少度睹加1*/
57. Status         ListDelete(sqlist *L, int i, ElemType *e)
58. {
59.         int k;
60.         if(L->length==0)                                         /*线性表为空*/
61.                 return ERROR;                                       
62.         if(i<1 || i>L->length)                                /*删除地位禁绝确*/
63.                 return ERROR;
64.         *e=L->data[i-1];
65.         if(i<L->length)                                                /*假如删除没有是最初的地位*/
66.         {
67.                 for(k=i; k<L->length; k++)                /*将删除地位后继元素前移*/
68.                 {
69.                         L->data[k-1]=L->data[k];
70.                 }
71.         }
72.        
73.         L->length--;
74.         return OK;
75. }//函数功用:改动元素
76. //初初前提:无
77. //操纵成果:将间接改动对应元素的值
78. Status ListChange(sqlist* L, ElemType oldnum, ElemType newnum)
79. {
80.         int k=0;
81.         for(k=0; k<L->length; k++)   //遍历找到要修正的元素oldnum,
82.         {
83.                 if(L->data[k]==oldnum)
84.                 {
85.                         L->data[k]=newnum;   //将oldnum交换为newnum
86.                         return OK;
87.                 }
88.         }
89.         return ERROR;
90. } //此函数只合用于元素范例为int
91. //函数功用:遍历挨次表
92. //初初前提:挨次表没有为空;
93. //操纵成果:挨印出线性表
94. void listprintf(sqlist *L)
95. {
96.         int k=0;
97.         for(k=0; k<L->length; k++)
98.         {
99.                 printf("第%d个元素: %d\n", k, L->data[k]);
100.         }
101. }int main(){//元素的插进                sqlist* L=listinit();        ListInsert(L, 1, 1);        ListInsert(L, 2, 2);                ListInsert(L, 3, 3);                        listprintf(L);//元素的删除                int e;        e=ListDelete(L, 1, &e);        printf("%d\n", e);        listprintf(L);        //获得元素                getELem(L,1,&e);        printf("%d\n", e);                //改动元素的值        ListChange(L,2,5);        listprintf(L);}

复造代码

（10）征象

  第0个元素: 1
第1个元素: 2
第2个元素: 3
1
第0个元素: 2
第1个元素: 3
2
第0个元素: 5
第1个元素: 3

1.静态挨次表
（1）静态挨次表观点
        静态挨次表的观点便是，挨次表的数组容量没有是牢固不变的，当挨次表的数组谦了，它能够大要本人增长挨次表的容量，不消担忧数组越界的成绩
（2）静态挨次表的构造体界说

1. //构造体界说
2. typedef int ElemType;                   /*ElemType范例按照实践状况而定,那里为int*/
3. typedef struct sqlist               
4. {
5.         ElemType *data;           /*界说一个元素指针*/
6.         int length;                                  /*线性表当前少度*/
7.         int capacity;             /*挨次表当前容量*/
8. }sqlist;
10. #define OK 1
11. #define ERROR 0
12. typedef int Status;  /*Status是函数的范例,其值是函数成果形态代码,如OK等*/

复造代码

        ·（1）数据范例为Elemtype,界说为int;
       · （2）data是一个元素指针，用去当数组的尾地点
       · （3） length代表数组少度,即当前的元素个数;
       · （4）capacity是挨次表容量
       · （5）Status代表函数的范例。
(3)静态挨次表初初化

1. /*函数功用:挨次表初初化*/
2. /*初初前提:无*/
3. /*操纵成果:无*/
4. sqlist* listinit()
5. {
6.         sqlist *L=(sqlist* )malloc(sizeof(struct sqlist));   //初初化构造体
7.         L->capacity=4;                                                                        //存储空间的初初分派量4
8.         L->data=malloc(sizeof(ElemType)*L->capacity);        //分派数组少度为4
9.         L->length=0;                                                                                 //数组少度初初化为0
10.         return L;
11. }

复造代码

   留意:此处返回的范例是挨次表构造体指针。
(4)静态挨次表的空间断定

1. //函数功用:判定挨次表空间能否另有空间
2. //初初前提:无
3. //操纵成果:
4. Status listcheck(sqlist* L)
5. {
6.         if(L->length>=L->capacity)
7.         {
8.                 L->capacity*=2;
9.                 L->data=realloc(L->data,L->capacity);
10.                 return ERROR;
11.         }
12.         return OK;
13. }

复造代码

        ·（1）L是挨次表的构造体指针;
（5）静态挨次表获得元素

1. /*函数功用:获得元素*/
2. /*初初前提:挨次线性表L已存正在,1<=i<listlength(L)*/
3. /*操纵成果:用e返回L中第i个元素的值,留意i指的是地位,第一个地位的数组是从0开端*/
4. Status getELem(sqlist* L, int i, ElemType *e)
5. {
6.         if(L->length==0 || i<1 || i>L->length)
7.                 return ERROR;
8.         *e=L->data[i-1];
9.        
10.         return OK;
11. }}

复造代码

            ·（1）L是挨次表的构造体指针;
            ·（2）i是您要得到的第几个元素的地位，留意i指的是地位,第一个地位的数组是从0开端;
            ·  (3) e是元素指针，将获得的元素赋值给e指背的变量。
（6）静态挨次表的插进操纵

1. /*函数功用:插进操纵*/
2. /*初初前提:挨次线性表L已存正在,1<=i<listlength(L)*/
3. /*操纵成果:正在L中第i个地位之前插进新的数据元素e,L的少度减1*/
4. Status ListInsert(sqlist *L, int i, ElemType e)
5. {
6.         listcheck(L);                      //查抄挨次表容量能否充足
7.         int k;
8.         if(i<1 || i>L->length+1)                   /*当i比第一名置小大概比最初一名后一名置借要年夜的时分*/
9.         {
10.                 return ERROR;                                   /*假如插进地位没有正在表尾*/
11.         }
12.        
13.         if(i<=L->length)                  //假如插进的地位是当前少度，跳过那一步
14.         {
15.                 for(k=L->length-1; k>=i; k--)        /*将要插进地位后的元素,背后移一名*/
16.                 {
17.                         L->data[k+1]=L->data[k];    /*将新元素插进*/
18.                 }
19.         }
20.         L->data[i-1]=e;
21.         L->length++;   
22.        
23.         return OK;
24. }

复造代码

        ·（1）L是挨次表的构造体指针;
       · （2）i是您要插进的地位，那里i的指的地位取上里的一样;
       · （3）e是您要插进的元素。
（7）静态挨次表的删除操纵

1. /*函数功用:删除元素*/
2. /*初初前提:挨次线性表L已存正在,1<=i<listlength(L)*/
3. /*操纵成果:删除L的第i个数据元素,并用e返回其值,L的少度睹加1*/
4. Status         ListDelete(sqlist *L, int i, ElemType *e)
5. {
6.         int k;
7.         if(L->length==0)                                         /*线性表为空*/
8.                 return ERROR;                                       
9.         if(i<1 || i>L->length)                                /*删除地位禁绝确*/
10.                 return ERROR;
11.         *e=L->data[i-1];
12.         if(i<L->length)                                                /*假如删除没有是最初的地位*/
13.         {
14.                 for(k=i; k<L->length; k++)                /*将删除地位后继元素前移*/
15.                 {
16.                         L->data[k-1]=L->data[k];
17.                 }
18.         }
19.        
20.         L->length--;
21.         return OK;
22. }

复造代码

        ·（1）L是挨次表的构造体指针;
        · （2）i是您要删除的地位，那里i的指的地位取上里的一样;
        ·  (3) e是元素指针，将获得的元素赋值给e指背的变量。
（8）静态挨次表的改动元素操纵

1. //函数功用:改动元素
2. //初初前提:无
3. //操纵成果:将间接改动对应元素的值
4. Status ListChange(sqlist* L, ElemType oldnum, ElemType newnum)
5. {
6.         int k=0;
7.         for(k=0; k<L->length; k++)   //遍历找到要修正的元素oldnum,
8.         {
9.                 if(L->data[k]==oldnum)
10.                 {
11.                         L->data[k]=newnum;   //将oldnum交换为newnum
12.                         return OK;
13.                 }
14.         }
15.         return ERROR;
16. }

复造代码

        ·（1）L是挨次表的构造体指针;
        ·（2）oldnum是本来的元素；
        ·（3）newnum是新的元素。
（9）挨印静态挨次表的元素

1. //此函数只合用于元素范例为int
2. //函数功用:遍历挨次表
3. //初初前提:挨次表没有为空;
4. //操纵成果:挨印出线性表
5. void listprintf(sqlist *L)
6. {
7.         int k=0;
8.         for(k=0; k<L->length; k++)
9.         {
10.                 printf("第%d个元素: %d\n", k, L->data[k]);
11.         }
12. }

复造代码

        留意:此函数只合适元素范例为int
     ·（1）L是挨次表的构造体指针;
（10）总代码

1. #include "stdio.h"#include #include //构造体界说
2. typedef int ElemType;                   /*ElemType范例按照实践状况而定,那里为int*/
3. typedef struct sqlist               
4. {
5.         ElemType *data;           /*界说一个元素指针*/
6.         int length;                                  /*线性表当前少度*/
7.         int capacity;             /*挨次表当前容量*/
8. }sqlist;
10. #define OK 1
11. #define ERROR 0
12. typedef int Status;  /*Status是函数的范例,其值是函数成果形态代码,如OK等*///函数功用:判定挨次表空间能否另有空间
13. //初初前提:无
14. //操纵成果:
15. Status listcheck(sqlist* L)
16. {
17.         if(L->length>=L->capacity)
18.         {
19.                 L->capacity*=2;
20.                 L->data=realloc(L->data,L->capacity);
21.                 return ERROR;
22.         }
23.         return OK;
24. }/*函数功用:挨次表初初化*/
25. /*初初前提:无*/
26. /*操纵成果:无*/
27. sqlist* listinit()
28. {
29.         sqlist *L=(sqlist* )malloc(sizeof(struct sqlist));   //初初化构造体
30.         L->capacity=4;                                                                        //存储空间的初初分派量4
31.         L->data=malloc(sizeof(ElemType)*L->capacity);        //分派数组少度为4
32.         L->length=0;                                                                                 //数组少度初初化为0
33.         return L;
34. }/*函数功用:获得元素*/
35. /*初初前提:挨次线性表L已存正在,1<=i<listlength(L)*/
36. /*操纵成果:用e返回L中第i个元素的值,留意i指的是地位,第一个地位的数组是从0开端*/
37. Status getELem(sqlist* L, int i, ElemType *e)
38. {
39.         if(L->length==0 || i<1 || i>L->length)
40.                 return ERROR;
41.         *e=L->data[i-1];
42.        
43.         return OK;
44. }/*函数功用:插进操纵*/
45. /*初初前提:挨次线性表L已存正在,1<=i<listlength(L)*/
46. /*操纵成果:正在L中第i个地位之前插进新的数据元素e,L的少度减1*/
47. Status ListInsert(sqlist *L, int i, ElemType e)
48. {
49.         listcheck(L);                      //查抄挨次表容量能否充足
50.         int k;
51.         if(i<1 || i>L->length+1)                   /*当i比第一名置小大概比最初一名后一名置借要年夜的时分*/
52.         {
53.                 return ERROR;                                   /*假如插进地位没有正在表尾*/
54.         }
55.        
56.         if(i<=L->length)                  //假如插进的地位是当前少度，跳过那一步
57.         {
58.                 for(k=L->length-1; k>=i; k--)        /*将要插进地位后的元素,背后移一名*/
59.                 {
60.                         L->data[k+1]=L->data[k];    /*将新元素插进*/
61.                 }
62.         }
63.         L->data[i-1]=e;
64.         L->length++;   
65.        
66.         return OK;
67. }/*函数功用:删除元素*/
68. /*初初前提:挨次线性表L已存正在,1<=i<listlength(L)*/
69. /*操纵成果:删除L的第i个数据元素,并用e返回其值,L的少度睹加1*/
70. Status         ListDelete(sqlist *L, int i, ElemType *e)
71. {
72.         int k;
73.         if(L->length==0)                                         /*线性表为空*/
74.                 return ERROR;                                       
75.         if(i<1 || i>L->length)                                /*删除地位禁绝确*/
76.                 return ERROR;
77.         *e=L->data[i-1];
78.         if(i<L->length)                                                /*假如删除没有是最初的地位*/
79.         {
80.                 for(k=i; k<L->length; k++)                /*将删除地位后继元素前移*/
81.                 {
82.                         L->data[k-1]=L->data[k];
83.                 }
84.         }
85.        
86.         L->length--;
87.         return OK;
88. }//函数功用:改动元素
89. //初初前提:无
90. //操纵成果:将间接改动对应元素的值
91. Status ListChange(sqlist* L, ElemType oldnum, ElemType newnum)
92. {
93.         int k=0;
94.         for(k=0; k<L->length; k++)   //遍历找到要修正的元素oldnum,
95.         {
96.                 if(L->data[k]==oldnum)
97.                 {
98.                         L->data[k]=newnum;   //将oldnum交换为newnum
99.                         return OK;
100.                 }
101.         }
102.         return ERROR;
103. } //此函数只合用于元素范例为int
104. //函数功用:遍历挨次表
105. //初初前提:挨次表没有为空;
106. //操纵成果:挨印出线性表
107. void listprintf(sqlist *L)
108. {
109.         int k=0;
110.         for(k=0; k<L->length; k++)
111.         {
112.                 printf("第%d个元素: %d\n", k, L->data[k]);
113.         }
114. }int main(){//元素的插进                sqlist* L=listinit();        ListInsert(L, 1, 1);        ListInsert(L, 2, 2);                ListInsert(L, 3, 3);        ListInsert(L, 4, 4);        ListInsert(L, 5, 5);                ListInsert(L, 6, 6);                listprintf(L);//元素的删除                int e;        e=ListDelete(L, 1, &e);        printf("%d\n", e);        listprintf(L);        //获得元素                getELem(L,1,&e);        printf("%d\n", e);                //改动元素的值        ListChange(L,2,5);        listprintf(L);}

复造代码

（11）征象

  第0个元素: 1
第1个元素: 2
第2个元素: 3
第3个元素: 4
第4个元素: 5
第5个元素: 6
1
第0个元素: 2
第1个元素: 3
第2个元素: 4
第3个元素: 5
第4个元素: 6
2
第0个元素: 5
第1个元素: 3
第2个元素: 4
第3个元素: 5
第4个元素: 6

 3.挨次表的劣缺陷
（1）长处
        ·不必为暗示表中元素之间的逻辑干系两而增长分外的存储空间
       ·能够疾速天获得表中任一名置的元素
（2）缺陷
       · 插进战删除操纵需求挪动大批元素
       ·当线性表少度变革较年夜时,易以肯定存储空间的容量，静态挨次表能够招致容量不敷，静态挨次表能够招致存储空间的华侈
       

免责声明：假如进犯了您的权益，请联络站少，我们会实时删除侵权内乱容，感谢协作！