今日学习：array数组的sort（），copyof（），tostring（）

最新推荐文章于 2024-03-05 20:42:28 发布

萌面喵

最新推荐文章于 2024-03-05 20:42:28 发布

阅读量303

点赞数

本文链接：https://blog.csdn.net/qq_44322569/article/details/104029481

版权

sort是一种排序算法
在这里插入图片描述
**

排序的作用

排序算法是为了让无序的数据组合变成有序的数据组合。
有序的数据组合最大的优势是在于当你进行数据定位和采用时，
会非常方便，因为这个数据是有序的，
从而在代码设计的时候会让你避免很多不必要的麻烦。

几种常见的排序算法

1.冒泡排序
3.插入排序
2.快速排序
4.归并排序
……还有什么拓扑排序等等太大佬的我也没看懂……

冒泡排序

原理：内循环第k次后，排在第k名的元素已被排好

if n < 2 {
    return；
}
for (int i=0;i<n;i++){
  for(int j=n-1;j>0;j--){
      if (A[j]>A[j-1]){
          int temp=A[j];
            A[j]=A[j-1];
            A[j-1]=temp;
      }
  }
}

插入排序

原理：对于一个排序好k个元素的数列，对下一个元素进行操作，使其插入在前面已经排序好的数列中，生成一个新的排序好k+1个元素的数列。

if n < 2 {
    return；
}
for (int i=0;i<n;i++){
  for (int j=i-1;j>=0;j--){
     if (A[j+1]<A[j]){
         int temp=A[j];
            A[j]=A[j+1];
            A[j+1]=temp; 
     }else{
         break;
     }
  }
}

减少交换次数的算法

if n < 2 {
    return
}
for (int i = 1; i < 10; i++) {
  int temp = A[i];
  for (int j = i; j >= 0; j--) {
    if (A[j - 1] > temp) {
      A[j] = A[j - 1];
    } else {
      A[j] = temp;
      break;
    }
  }
}

快速排序

原理：对于一个数列，取其中一个元素为基准，对剩余元素进行判断，比基准大的和比基准小的元素各方在基准两侧，操作完成后，将基准两侧的数列看成两个新数列，重复操作。

void qsort(int A[],int m,int n){
if (n-m<1){
    return;
}
int pivot=A[m];
int k=m;
for (int i=m+1;i<n;i++){
  if (A[i]>pivot){
    int q1=A[i];
      for (int j=i-1;j>=m;j--){
          A[j+1]=A[j];
      }
    A[m]=q1;
    k++;
  }
}
qsort(A,m,k);qsort(A,k+1,n);
}

void quickSort(int s[], int l, int r)
{
if (l < r)
{
    int i = l, j = r, x = s[l];
    while (i < j)
    {
        while (i < j && s[j] >= x) // 从右向左找第一个小于x的数
            j--;
        if (i < j)
            s[i++] = s[j];

        while (i < j && s[i] < x) // 从左向右找第一个大于等于x的数
            i++;
        if (i < j)
            s[j--] = s[i];
    }
    s[i] = x;
    quickSort(s, l, i - 1); // 递归调用
    quickSort(s, i + 1, r);
}
}

归并排序

原理：找内存再要一个大小相等的空间，先将原数列拆为只含一个元素的单体进行排列，再进行合并。

void merge_sort_recursive(int arr[], int reg[], int start, int end) {
if (start >= end)
    return;
int len = end - start, mid = (len >> 1) + start;
int start1 = start, end1 = mid;
int start2 = mid + 1, end2 = end;
merge_sort_recursive(arr, reg, start1, end1);
merge_sort_recursive(arr, reg, start2, end2);
int k = start;
while (start1 <= end1 && start2 <= end2)
    reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
while (start1 <= end1)
    reg[k++] = arr[start1++];
while (start2 <= end2)
    reg[k++] = arr[start2++];
for (k = start; k <= end; k++)
    arr[k] = reg[k];
}
void merge_sort(int arr[], const int len) {
int reg[len];
merge_sort_recursive(arr, reg, 0, len - 1);
}

copyof（）是一种数组复制的操作方法

**
这个方式必须明确自行新建立一个数组对象。在JDK 6中，Arrays 类别新增了copyOf()方法，可以直接传回一个新的数组对象，而当中包括复制的内容，Array.copyOf() 用于复制指定的数组内容以达到扩容的目的，该方法对不同的基本数据类型都有对应的重载方法，Arrays的copyOf()方法传回的数组是新的数组对象，所以您改变传回数组中的元素值，也不会影响原来的数组，copyOf()的第二个自变量指定要建立的新数组长度，如果新数组的长度超过原数组的长度，则保留数组默认值
还有一种是system.arraycopy（）
src：源对象
srcPos：源数组中的起始位置
dest：目标数组对象
destPos：目标数据中的起始位置
length：要拷贝的数组元素的数量

toStirng方法是Object类中的方法

定义为下图，其返回值为String类型

public String toString()

在进行String与其他类型数据的连接操作时，（如下图）,将调用改对象类的toSting()方法

public class He{	
public static void main(String[] args)	{	    
Person p = new Person();		
System.out.println("HelloWorld"+p);
	} 
	} 
	class Person{}

输出是：HelloWorldPerson@65b54208

官网的注释toStirng():

toString用于类的方法Object 返回一个字符串，该字符串由对象作为实例的类的名称，符号字符“ @”和对象的哈希码的无符号十六进制表示组成。换句话说，此方法返回的字符串等于：

getClass（）.getName（）+'@'+ Integer.toHexString（hashCode（））

可以根据需要在用户自定义类型中重写toString()方法

public class He{	
public static void main(String[] args)	{		
Person p = new Person();		
System.out.println("HelloWorld"+p);
	} 
	}
	class Person{	
	public String toString(){	    
	return"i'm a cool man ";	
	}}

本人的一次作业：

**
题目01_2
学号数组：String[] stuNo = { “2019011535”, “2019011534”, “2019011539”, “2019011538”, “2019011537” }
姓名数组：String[] stuName = { “张三”, “李四”, “王五”, “赵六”, “王九” }
成绩数组：int[] stuScore = { 53, 78, 96, 66, 85 }
学号姓名成绩一一对应
写Java程序，要求实现以下功能（提示：可以使用Arrays类中的方法sort()、copyOf()、toString()）：
（1）计算成绩数组中最大值、最小值、所有值之和，并输出到控制台。
（2）分别对以上三组数据排序，向控制台输出排序前和排序后的内容。
（3）将（2）中排序好的内容复制到另外三个数组中。
（4）根据成绩排序，要求保持学号、姓名、成绩对应（选作）。

public class HomeWork {
public static void main(String[] args) {
	work1();
	System.out.println("99乘法表");
	work2();//99乘法表
}

private static void work2() {
	for(int i=9;i>=1;i--){
			for( int j=1;j<=i;j++){
				System.out.print(j+"*"+i+"="+i*j+"\t");
			}
			System.out.println();
			for( int j=0;j<=9-i;j++){
			System.out.print("\t");
			}
		}
		System.out.println();
}

private static void work1() {
	String[] stuNo=new String[]{"2019011535","2019011534","2019011539","2019011538","2019011537"};
	String[] stuName=new String[]{"张三","李四","王五","赵六","王九"};
	int[] stuScore=new int[]{53,66,78,85,96};
	int max=stuScore[0];
	int min=stuScore[0];
	int sum=0;
	for(int i=0;i<stuScore.length;i++){
		//最大值
		if(stuScore[i]>max){
			max=stuScore[i];
		}
		//最小值
		if(stuScore[i]<min){
			min=stuScore[i];
		}
		sum+=stuScore[i];//所有值之和	
	}
	System.out.println("最大值:"+max);
	System.out.println("最小值:"+min);
	System.out.println("所有值之和:"+sum);
	//默认升序
	Arrays.sort(stuNo);
	Arrays.sort(stuName);
	Arrays.sort(stuScore);
	System.out.println("学号排序前:");
		for(int i=0;i<stuNo.length;i++){
			System.out.println(stuNo[i]);
		}
	System.out.println("学号排序后:");
	for(int i=stuNo.length-1;i>=0;i--){
		System.out.println(stuNo[i]);
	}
	System.out.println("名字排序前:");
	for(int i=stuName.length-1;i>=0;i--){
		System.out.println(stuName[i]);
	}
	System.out.println("名字排序后:");
	for(int i=0;i<stuName.length;i++){
		System.out.println(stuName[i]);
	}
	System.out.println("成绩排序前:");
	for(int i=0;i<stuScore.length;i++){
		System.out.println(stuScore[i]);
	}
	System.out.println("成绩排序后:");
	for(int i=stuScore.length-1;i>=0;i--){
		System.out.println(stuScore[i]);
		
	}
	//学号排序前+排序后
	String[] stuNoCopy=Arrays.copyOf(stuNo, 5);
	System.out.println("学号排序前+排序后:");
	String[] NewStuNo=new String[stuNo.length+stuNoCopy.length];
	System.arraycopy(stuNo, 0, NewStuNo, 0, stuNo.length);
	System.arraycopy(stuNoCopy, 0, NewStuNo, stuNo.length, stuNoCopy.length);
	String nsn=Arrays.toString(NewStuNo);
	System.out.println(nsn);
	//名字排序前+排序后
	String[] stuNameCopy=Arrays.copyOf(stuName, 5);
	System.out.println("名字排序前+排序后:");
	String[] NewStuName=new String[stuName.length+stuNameCopy.length];
	System.arraycopy(stuName, 0, NewStuName, 0, stuName.length);
	System.arraycopy(stuNameCopy, 0, NewStuName, stuName.length, stuNameCopy.length);
	String nsna=Arrays.toString(NewStuName);
	System.out.println(nsna);
	//成绩排序前+排序后
	int[] stuScoreCopy=Arrays.copyOf(stuScore, 5);
	System.out.println("成绩排序前+排序后:");
	int[] NewStuScore=new int[stuScore.length+stuScoreCopy.length];
	System.arraycopy(stuScore, 0, NewStuScore, 0, stuScore.length);
	System.arraycopy(stuScoreCopy, 0, NewStuScore, stuScore.length, stuScoreCopy.length);
	String nsc=Arrays.toString(NewStuScore);
	System.out.println(nsc);
}

}

萌面喵

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
今日学习：array数组的sort（），copyof（），tostring（）

sort是一种排序算法**排序的作用**排序算法是为了让无序的数据组合变成有序的数据组合。有序的数据组合最大的优势是在于当你进行数据定位和采用时，会非常方便，因为这个数据是有序的，从而在代码设计的时候会让你避免很多不必要的麻烦。**几种常见的排序算法**1.冒泡排序3.插入排序2.快速排序4.归并排序……还有什么拓扑排序等等太大佬的我也没看懂……冒泡排序原理...
复制链接

扫一扫