20192304 实验七 《数据结构和面向对象的程序设计》 实验报告

20192304 2020-2021-1 《数据结构与面向对象程序设计》实验七报告

课程:《程序设计与数据结构》
班级: 1923
姓名: 刘润衡
学号:20192304
实验教师:王志强
实验日期:2020年11月19日
必修/选修: 必修

1.实验内容

(1)定义一个Searching和Sorting类,并在类中实现linearSearch,SelectionSort方法,最后完成测试。
要求不少于10个测试用例,提交测试用例设计情况(正常,异常,边界,正序,逆序),用例数据中要包含自己学号的后四位
提交运行结果图。

(2)把Sorting.java Searching.java放入 cn.edu.besti.cs1823.(姓名首字母+四位学号) 包中(例如:cn.edu.besti.cs1823.G2301)
把测试代码放test包中
重新编译,运行代码,提交编译,运行的截图(IDEA,命令行两种
(3)参考http://www.cnblogs.com/maybe2030/p/4715035.html ,学习各种查找算法并在Searching中补充查找算法并测试
提交运行结果截图
(4)补充实现课上讲过的排序方法:希尔排序,堆排序,二叉树排序等(至少3个)
测试实现的算法(正常,异常,边界)
提交运行结果截图
(3分,如果编写多个排序算法,即使其中三个排序程序有瑕疵,也可以酌情得满分)

2. 实验过程及结果

(1)
【1】定义一个Searching和Sorting类,并在类中实现linearSearch,SelectionSort方法,最后完成测试。
要求不少于10个测试用例,提交测试用例设计情况(正常,异常,边界,正序,逆序),用例数据中要包含自己学号的后四位
提交运行结果图。
【2】

https://gitee.com/besti1923/lrh20192304_JAVAProgramrr/blob/master/src/SearchingTest.java

public class Sorting
{
public static void selectionSort (Comparable[] data)
{
int min;
for (int index = 0; index < data.length-1; index++)
{
min = index;
for (int scan = index+1; scan < data.length; scan++)
if (data[scan].compareTo(data[min]) < 0)
min = scan;
swap (data, min, index);
}
}

private static void swap (Comparable[] data, int index1, int index2)
{
    Comparable temp = data[index1];
    data[index1] = data[index2];
    data[index2] = temp;
}

public String print(Comparable[] data){
    String result = "";
    for(int i=0;i<data.length;i++)
        result += ""+data[i]+" ";
    return result;
}

}

import junit.framework.TestCase;
import org.junit.Test;

public class SearchingTest extends TestCase {
Searching a = new Searching();
Sorting b = new Sorting();

@Test
public void testSearching()
{
    int[] t1 = {19,14,23,1,68,20,84,27,55,11,10,79};
    assertEquals(false,a.linearSearch(t1,9,12));
    assertEquals(true,a.linearSearch(t1,1,12));
    assertEquals("Abnormal",a.linearSearch(t1,1,18));
    assertEquals(true,a.linearSearch(t1,79,12));

    int[] t2 = {5,2,7,43,21,65,23};
    assertEquals(true,a.linearSearch(t2,2,7));
    assertEquals(false,a.linearSearch(t2,42314,7));
    assertEquals("Abnormal",a.linearSearch(t2,1,18));
    assertEquals(true,a.linearSearch(t2,5,7));

    int[] t3 = {1,24,5,5,2,2,45,56};
    assertEquals(true,a.linearSearch(t3,24,8));
    assertEquals(false,a.linearSearch(t3,0,8));
    assertEquals("Abnormal",a.linearSearch(t3,1,18));
    assertEquals(true,a.linearSearch(t3,56,8));

    int[] t4 = {2,423,42,435,32,45,4,43,2};
    assertEquals(true,a.linearSearch(t4,4,9));
    assertEquals(false,a.linearSearch(t4,123,9));
    assertEquals("Abnormal",a.linearSearch(t4,1,18));
    assertEquals(true,a.linearSearch(t4,2,9));

    int[] t5 = {967,65,5687,56,332,46,23};
    assertEquals(true,a.linearSearch(t5,332,7));
    assertEquals(false,a.linearSearch(t5,12,7));
    assertEquals("Abnormal",a.linearSearch(t5,1,18));
    assertEquals(true,a.linearSearch(t5,967,7));
}

@Test
public void testSorting(){
    Comparable[] t6 = {2,6,9,55,8,66};
    b.selectionSort(t6);
    assertEquals("2 6 8 9 55 66 ",b.print(t6));

    Comparable[] t7 = {1,2,6,4,9,10};
    b.selectionSort(t7);
    assertEquals("1 2 4 6 9 10 ",b.print(t7));

    Comparable[] t8 = {1,8,4,3,5,16};
    b.selectionSort(t8);
    assertEquals("1 3 4 5 8 16 ",b.print(t8));             //正排

    Comparable[] t9 = {36,27,24,16,10};
    b.selectionSort(t9);
    assertEquals("10 16 24 27 36 ",b.print(t9));

    Comparable[] t10 = {100,98,66,11};
    b.selectionSort(t10);
    assertEquals("11 66 98 100 ",b.print(t10));            //倒排

    Comparable[] t11 = {20,19,23,4};
    b.selectionSort(t11);
    assertEquals("4 19 20 23 ",b.print(t11));               //学号排
}

}

public class Searching
{
public static Comparable linearSearch (int[] arr,int target,int length)
{
int i=0;
int a = target;
if(length>arr.length)
return "Abnormal";
else
{
while(arr[i]!=target)
{
i++;
if(iarr.length)
break;
}
return i
arr.length?false:true;
}
}
}

(2)
【1】把Sorting.java Searching.java放入 cn.edu.besti.cs1823.(姓名首字母+四位学号) 包中(例如:cn.edu.besti.cs1823.G2301)
把测试代码放test包中
重新编译,运行代码,提交编译,运行的截图(IDEA,命令行两种
【2】

package test;

import cn.edu.besti.cs1923.Searching;
import cn.edu.besti.cs1923.Sorting;
import junit.framework.TestCase;
import org.junit.Test;

public class SearchingTest extends TestCase {
Searching a = new Searching();
Sorting b = new Sorting();

@Test
public void testSearching()
{
    int[] t1 = {19,14,23,1,68,20,84,27,55,11,10,79};
    assertEquals(false,a.linearSearch(t1,9,12));
    assertEquals(true,a.linearSearch(t1,1,12));
    assertEquals("Abnormal",a.linearSearch(t1,1,18));
    assertEquals(true,a.linearSearch(t1,79,12));

    int[] t2 = {5,2,7,43,21,65,23};
    assertEquals(true,a.linearSearch(t2,2,7));
    assertEquals(false,a.linearSearch(t2,42314,7));
    assertEquals("Abnormal",a.linearSearch(t2,1,18));
    assertEquals(true,a.linearSearch(t2,5,7));

    int[] t3 = {1,24,5,5,2,2,45,56};
    assertEquals(true,a.linearSearch(t3,24,8));
    assertEquals(false,a.linearSearch(t3,0,8));
    assertEquals("Abnormal",a.linearSearch(t3,1,18));
    assertEquals(true,a.linearSearch(t3,56,8));

    int[] t4 = {2,423,42,435,32,45,4,43,2};
    assertEquals(true,a.linearSearch(t4,4,9));
    assertEquals(false,a.linearSearch(t4,123,9));
    assertEquals("Abnormal",a.linearSearch(t4,1,18));
    assertEquals(true,a.linearSearch(t4,2,9));

    int[] t5 = {967,65,5687,56,332,46,23};
    assertEquals(true,a.linearSearch(t5,332,7));
    assertEquals(false,a.linearSearch(t5,12,7));
    assertEquals("Abnormal",a.linearSearch(t5,1,18));
    assertEquals(true,a.linearSearch(t5,967,7));
}

@Test
public void testSorting(){
    Comparable[] t6 = {2,6,9,55,8,66};
    b.selectionSort(t6);
    assertEquals("2 6 8 9 55 66 ",b.print(t6));

    Comparable[] t7 = {1,2,6,4,9,10};
    b.selectionSort(t7);
    assertEquals("1 2 4 6 9 10 ",b.print(t7));

    Comparable[] t8 = {1,8,4,3,5,16};
    b.selectionSort(t8);
    assertEquals("1 3 4 5 8 16 ",b.print(t8));             //正排

    Comparable[] t9 = {36,27,24,16,10};
    b.selectionSort(t9);
    assertEquals("10 16 24 27 36 ",b.print(t9));

    Comparable[] t10 = {100,98,66,11};
    b.selectionSort(t10);
    assertEquals("11 66 98 100 ",b.print(t10));            //倒排

    Comparable[] t11 = {20,19,23,4};
    b.selectionSort(t11);
    assertEquals("4 19 20 23 ",b.print(t11));               //学号排
}

}

package cn.edu.besti.cs1923;

public class Searching
{
public static Comparable linearSearch (int[] arr,int target,int length)
{
int i=0;
int a = target;
if(length>arr.length)
return "Abnormal";
else
{
while(arr[i]!=target)
{
i++;
if(iarr.length)
break;
}
return i
arr.length?false:true;
}
}
}

package cn.edu.besti.cs1923;

public class Sorting
{
public static void selectionSort (Comparable[] data)
{
int min;
for (int index = 0; index < data.length-1; index++)
{
min = index;
for (int scan = index+1; scan < data.length; scan++)
if (data[scan].compareTo(data[min]) < 0)
min = scan;
swap (data, min, index);
}
}

private static void swap (Comparable[] data, int index1, int index2)
{
    Comparable temp = data[index1];
    data[index1] = data[index2];
    data[index2] = temp;
}

public String print(Comparable[] data){
    String result = "";
    for(int i=0;i<data.length;i++)
        result += ""+data[i]+" ";
    return result;
}

}

(3)
【1】参考http://www.cnblogs.com/maybe2030/p/4715035.html ,学习各种查找算法并在Searching中补充查找算法并测试
提交运行结果截图
【2】

package cn.edu.besti.cs1923;

import java.util.Scanner;

public class SearchRunTest {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);

    Searching asl = new Searching();
    int target = 0,i,j=0;

    int[] arr = {19,23,4,11,68,20,84,27,55,11,10,79};
    System.out.println("列表:");
    System.out.println(asl.print(arr));

   /*System.out.println("斐波那契查找,输入要查找的数:");
    target = scan.nextInt();
    System.out.println("是否找到:"+asl.FibonacciSearch(arr,target));*/
    System.out.println("分块查找,输入要查找的数:");
    target = scan.nextInt();
    int re1 = asl.blocking(arr,target);
    if(re1==0)
        System.out.println("查找失败!数组中无此数!");
    else
        System.out.println("查找成功!查找到的数是:"+re1);
    target = scan.nextInt();
    int re2 = asl.blocking(arr,target);
    if(re2==0)
        System.out.println("查找失败!数组中无此数!");
    else
        System.out.println("查找成功!查找到的数是:"+re2);
}

}

package cn.edu.besti.cs1923;
public class Linked {
public int a;
public Linked next = null;
public Linked temp,top;
public int element;

public Linked(int a) {
    this.a = a;
}

public int getnum(){
    //String b = Integer.toString(a);
    return a;
}

public void setNext(Linked next){
    this.next=next;
}

public Linked getNext() {
    return next;
}

public void insert(Linked Head, int a, Linked insertnode){
    Linked temp = Head;
    if(a==0){
        insertnode.setNext(temp);
        //Head = insertnode;
    }
    else {
        for(int i=0;i<a;i++)
        {
            top = temp;
            temp = temp.getNext();
        }
        top.setNext(insertnode);
        insertnode.setNext(temp);
        temp=top;
    }
}

public void delete(Linked Head, int a){
    Linked temp = Head;
    int i=0;
    if(a==0)
    {
        ;
    }
    else {
        while(i!=a-1){
            temp = temp.getNext();
            i++;
        }
        top = temp;
        temp=temp.getNext();
        temp=temp.getNext();
        top.setNext(temp);
        temp=top;
    }
}

public void sort(Linked Head, int count){
    Linked temp = Head;
    Linked c,d;
    for(int i = 0;i<count-1;i++)
    {
        c = temp;
        d = c.getNext();
        for(int j =0;j<count-i-1;j++)
        {
            if((c.getElement())<(d.getElement()))
            {
                int t;
                t = c.getElement();
                c.setElement(d.getElement());
                d.setElement(t);
            }
            c=c.getNext();
            d=d.getNext();
        }
    }
}

public int getElement()
{
    return a;
}

public void setElement (int elem)
{
    a=elem;
}


public String print(Linked head){
    String result="元素:\n"+head.getnum()+"\n";
    while(head.getNext()!=null){
        result +=(head.getNext()).getnum()+"\n";
        head=head.getNext();
    }
    return result;
}

}

package cn.edu.besti.cs1923;

import cn.edu.besti.cs1923.Linked;

public class Searching
{

public boolean order(int[] arr,int target){
    int i=0;
    int a = target;
    while(arr[i]!=target)
    {
        i++;
        if(i==arr.length)
            break;
    }
    return i==arr.length?false:true;
}

public void sort(int arr[]){
    for(int i =1;i<arr.length;i++) {
        for(int j=0;j<arr.length-i;j++) {
            if(arr[j]>arr[j+1]) {
                int temp = arr[j];

                arr[j]=arr[j+1];

                arr[j+1]=temp;
            }
        }
    }
}

public boolean binary(int[] arr,int min,int max,int mid,int target){
    boolean found = false;
    mid = (min + max) / 2;
    int midd = mid;

    if(arr[midd]==target)
        found = true;
    else if (arr[midd]!=target)
    {
        if(target<arr[midd])
        {
            max = midd-1;
            midd--;
            found = binary(arr,min,max,midd,target);
        }
        else if(target>arr[midd])
        {
            min = midd+1;
            midd++;
            found = binary(arr,min,max,midd,target);
        }
    }
    return found;
}

public int binaryshow(int[] arr,int min,int max,int mid,int target){
    int found = 0;
    mid = (min + max) / 2;
    int midd = mid;

    if(arr[midd]==target)
        found = arr[midd];
    else if (arr[midd]!=target)
    {
        if(target<arr[midd])
        {

            max = midd-1;
            midd--;
            found = binaryshow(arr,min,max,midd,target);
        }
        else if(target>arr[midd])
        {
            min = midd+1;
            midd++;
            found = binaryshow(arr,min,max,midd,target);
        }
    }
    return found;
}

public int[] hash(int[] arr){
    int[] arr1 = {0,0,0,0,0,0,0,0,0,0,0,0};
    for(int i=0;i<arr.length;i++)
    {
        if(arr1[arr[i]%11] == 0)
            arr1[arr[i]%11] = arr[i];
        else
        {
            for(int j=2;j<arr.length;j++)
                if(arr1[j-1] == 0)
                {
                    arr1[j-1] = arr[i];
                    break;
                }
        }
    }
    return arr1;
}

public int hashsearch(int[] result,int target){
    int k = target%11,i,re = 0;
    if(result[k]==target)
        re =  result[k];
    else
    {
        for(i=k;k<result.length;k++)
        {
            if(result[k]==target)
            {
                re = result[k];
                break;
            }
        }
    }
    return re;
}

public Linked[] linkedhash(Linked[] linked){
    Linked[] arr1 = new Linked[12];
    int i;
    for(i=0;i<12;i++)
        arr1[i] = new Linked(0);
    for(i=0;i<linked.length;i++)
    {
        if((arr1[linked[i].getnum()%11]).getnum() == 0)
            arr1[linked[i].getnum()%11] = linked[i];
        else
        {
            arr1[linked[i].getnum()%11].setNext(linked[i]);
        }
    }
    return arr1;
}

public int linkedsearch(Linked[] re1, int target){
    int k = target%11,i,re = 0;
    if(re1[k].getnum()==target)
        re = re1[k].getnum();
    else
    {
        Linked re2 = re1[k].getNext();
        //re2 = new Linked(0);
        if(re2.getnum()==target)
            re = re2.getnum();
    }
    return re;
}

public static boolean FibonacciSearch(int[] table, int keyWord) {
    //确定需要的斐波那契数
    int i = 0;
    while (getFibonacci(i) - 1 == table.length) {
        i++;
    }
    //开始查找
    int low = 0;
    int height = table.length - 1;
    while (low <= height) {
        int mid = low + getFibonacci(i - 1);
        if (table[mid] == keyWord) {
            return true;
        } else if (table[mid] > keyWord) {
            height = mid - 1;
            i--;
        } else if (table[mid] < keyWord) {
            low = mid + 1;
            i -= 2;
        }
    }
    return false;
}

public static int getFibonacci(int n) {
    int res = 0;
    if (n == 0) {
        res = 0;
    } else if (n == 1) {
        res = 1;
    } else {
        int first = 0;
        int second = 1;
        for (int i = 2; i <= n; i++) {
            res = first + second;
            first = second;
            second = res;
        }
    }
    return res;
}

public static int InsertionSearch(int[] a, int value, int low, int high) {
    int mid = low + (value - a[low]) / (a[high] - a[low]) * (high - low);
    if (a[mid] == value)
        return a[mid];
    if (a[mid] > value)
        return InsertionSearch(a, value, low, mid - 1);
    else
        return InsertionSearch(a, value, mid + 1, high);
}

public static int blocking(int[] arr,int target){
    int[] ar1 = new int[arr.length];
    int[] ar2 = new int[arr.length];
    int[] ar3 = new int[arr.length];
    int i=0,j=0,k=0,l=0;
    int result = 0;
    for(i=0;i<arr.length;i++)
    {
        if(0<=arr[i]&&arr[i]<=20)
        {
            ar1[j] = arr[i];
            j++;
        }
        else if (20<arr[i]&&arr[i]<=60)
        {
            ar2[k] = arr[i];
            k++;
        }
        else
        {
            ar3[l] = arr[i];
            l++;
        }
    }
    i=0;
    if(0<=target&&target<=20)
    {
        for(i=0;i<ar1.length;i++)
            if(ar1[i]==target)
            {
                result = ar1[i];
                break;
            }
    }
    else if (20<target&&target<=60)
    {
        for(i=0;i<ar2.length;i++)
            if(ar2[i]==target)
            {
                result = ar2[i];
                break;
            }
    }
    else
    {
        for(i=0;i<ar3.length;i++)
            if(ar3[i]==target)
            {
                result = ar3[i];
                break;
            }
    }
    return result;
}

public static void ShellSort(int[] data)
{
    int i= 0, temp = 0, j = 2;
    for (int incr = data.length / j; incr > 0; incr /= j)
    {
        for (int x = incr; x < data.length; x++)
        {
            temp = (int) data[x];
            for (i = x - incr; i >= 0; i -= incr)
            {

                if (temp < (int) data[i])
                    data[i + incr] = data[i];
                else
                    break;
            }
            data[i + incr] = temp;
        }
    }
}

public String print(int[] arr){
    String result = "";
    for(int i=0;i<arr.length;i++)
        result += ""+arr[i]+" ";
    return result;
}

}

(4)
【1】补充实现课上讲过的排序方法:希尔排序,堆排序,二叉树排序等(至少3个)
测试实现的算法(正常,异常,边界)
提交运行结果截图
【2】

https://gitee.com/besti1923/lrh20192304_JAVAProgramrr/commit/85efa2b2e95accea5eeed53e81e5c218c53bfa4e

import java.util.Stack;

public class SearchingSortTest {
public static void main(String[] args) {

    int []test=new int[10];
    test[0]=1;
    test[1]=10;
    test[2]=1;
    test[3]=8;
    test[4]=8;
    test[5]=6;
    test[6]=2;
    test[7]=3;
    test[8]=0;
    test[9]=4;

    Searching searching=new Searching();
    System.out.println("线性查找: ");
    searching.linear(test, 1);
    Sorting sorting=new Sorting();
    sorting.selectionSort(test);
    searching.binarySearch(test, 2);
    System.out.println("二分查找: ");
    System.out.println("找到目标数的下标:"+searching.binSearch(test, 0, test.length-1, 1));
    System.out.println("插值查找: ");
    System.out.println("找到目标数的下标:"+searching.insertSearch(test, 0, test.length-1, 1));
    System.out.println("斐波那契查找: ");
    System.out.println("找到目标数的下标:"+ searching.fibSearch(test,3));

    /*Sorting sorting=new Sorting();*/
    System.out.println("希尔排序: ");
    sorting.shellSort(test);
    /*Sorting sorting=new Sorting();*/
    System.out.println("直接插入排序: ");
    sorting.insertSort(test);

}

}

import java.util.Arrays;

public class Searching {

public void   linear(int[] data, int target)
{
    int count=0;
    for(int i = 0; i < data.length; i++) {
        if(data[i]==target){ count++;System.out.println("找到目标数的下标:"+i);
        }
    }
    if (count==0)
        System.out.println("没有找到目标数");
    else
        System.out.println("共有"+count+"个");
}
public void binarySearch(int[] data,int target)
{
    int count=0;
    int low,high,mid;
    low=0;
    high=data.length-1;

    while (low<=high)
    {
        mid=(low+high)/2;
        if(data[mid]==target)
        { count++;
            System.out.println("找到目标数的下标:"+mid);
            break;
        }
        else if (data[mid]>target)
        {
            high=mid-1;
        }
        else
            low=mid+1;
    }
    if (count==0)
        System.out.println("没有找到目标数");
    else
        System.out.println("共有"+count+"个");

}
public  int binSearch(int srcArray[], int start, int end, int target) {
    int mid = (end - start) / 2 + start;
    if (srcArray[mid] == target) {
        return mid;
    }
    if (start >= end) {
        return -1;
    } else if (target > srcArray[mid]) {
        return binSearch(srcArray, mid + 1, end, target);
    } else if (target < srcArray[mid]) {
        return binSearch(srcArray, start, mid - 1, target);
    }
    return -1;
}

public    int insertSearch(int []data,int  left,int right,int target){

    if(left>right || target<data[0] ||target>data[data.length-1]){
        return -1;
    }

    int mid = left +(right - left) * (target - data[left])/ (data[right] -data[left]);
    int midVal =data[mid];
    if(target > midVal){
        return insertSearch(data, mid+1, right, target);

    }else if(target < midVal){
        return insertSearch(data, left, mid-1, target);
    }else {
        return mid;
    }
}
public static int[] fib(int []data) {
    int[] f = new int[data.length];
    f[0] = 1;
    f[1] = 1;
    for (int i = 2; i < data.length; i++) {
        f[i] = f[i - 1] + f[i - 2];
    }
    return f;
}
public  int fibSearch(int[] a, int target) {
    int low = 0;
    int high = a.length - 1;
    int k = 0;
    int mid = 0;
    int f[] = fib(a);
    while (high > f[k] - 1) {
        k++;
    }
    int[] temp = Arrays.copyOf(a, f[k]);
    for (int i = high + 1; i < temp.length; i++) {
        temp[i] = a[high];
    }
    while (low <= high) {
        mid = low + f[k - 1] - 1;
        if (target < temp[mid]) {
            high = mid - 1;
            k--;
        } else if (target > temp[mid]) {
            low = mid + 1;
            k -= 2;
        } else {
            if (mid <= high) {
                return mid;
            } else {
                return high;
            }
        }
    }
    return -1;
}

}

public class Sorting {

public void selectionSort(int[] data)
{
    int min=0;
    for(int i=0;i<data.length;i++)
    {

        for (int j=i+1;j<data.length;j++)
        {
            if(data[i]>data[j])
            {min=data[j];
                data[j]=data[i];
                data[i]=min;}

        }

    }
    for(int i=0;i<data.length;i++)
    {
        System.out.println("test"+"["+i+"]"+": "+data[i]);
    }
}
public void insertSort(int []data)
{
    int temp;
    int j ;
    for(int i=1;i<data.length;i++)
    {
        temp=data[i];//待插入的数
        for ( j=i-1;j>=0&&data[j]>=temp;j--)
        {
            data[j+1]=data[j];
        }
        data[j+1]=temp;

    }
    for(int i=0;i<data.length;i++)
    {
        System.out.println("test"+"["+i+"]"+": "+data[i]);
    }
}

public  void shellSort(int[] data)
{
    int j = 0;
    int temp = 0;
    for (int increment = data.length / 2; increment > 0; increment /= 2)
    {
        for (int i = increment; i < data.length; i++)
        {
            temp = data[i];
            for (j = i; j >= increment&&temp <data[j - increment]; j -= increment)
            {
                data[j] = data[j - increment];
            }
            data[j] = temp;
        }

    }
    for(int i=0;i<data.length;i++)
    {
        System.out.println("test"+"["+i+"]"+": "+data[i]);
    }
}

}

3. 实验过程中遇到的问题和解决过程

1.虚拟机物理状态损坏;借用同学虚拟机完成。
2.将代码置入其他包,需要将测试代码同样置入该包才能继续使用。

其他(感悟、思考等)

参考资料

posted @ 2020-11-28 17:11  20192304刘润衡  阅读(19)  评论(0编辑  收藏