0
点赞
收藏
分享

微信扫一扫

Java学习记录 Day11(StringBuffer、排序算法)

求阙者 2022-09-06 阅读 63


文章目录

  • ​​Day 11​​
  • ​​StringBuffer类​​
  • ​​排序算法​​

Day 11

2019年4月27日。
这是我学习Java的第十一天。
这一天,我学到了以下的知识。

StringBuffer类

StringBuffer,是一个长度可变的字节容器,可以存储多个字符,也可以不断的往容器中追加内容。

构造方法:​public StringBuffer() // 无参构造方法​​​​public StringBuffer(int capacity) // 指定容量的字符串缓冲区对象​​​​public StringBuffer(String str) // 指定字符串内容的字符串缓冲区对象​

常用的成员方法

  • 返回功能
  • ​public int capacity()​​:返回当前容量
    - 默认情况下,初始容量为16
  • ​public int length()​​:返回长度(字符数)
  • 添加功能
  • ​public StringBuffer append(String str)​​:可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
  • ​public StringBuffer insert(int offset,String str)​​:在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
  • 删除功能
  • ​public StringBuffer deleteCharAt(int index)​​:删除指定位置的字符,并返回本身
  • ​public StringBuffer delete(int start,int end)​​:删除从指定位置开始指定位置结束的内容,并返回本身
  • 替换功能
  • ​public StringBuffer replace(int start,int end,String str)​​:从start开始到end用str替换
  • 反转功能
  • ​public StringBuffer reverse()​​:字符串反转
  • 截取功能
  • ​public String substring(int start)​​:从指定位置截取到末尾
  • ​public String substring(int start,int end)​​:截取从指定位置开始到结束位置,包括开始位置,不包括结束位置

StringBuffer和String的相互转换

  • String – StringBuffer
    - 通过构造方法
    - 通过append()方法
  • StringBuffer – String
    - 使用substring方法
    - 通过构造方法
    - 通过toString()方法

排序算法

  • 冒泡排序
    原理:相邻元素两两比较,大的往后放,第一次完毕,最大值出现在了最大索引处
  • Java学习记录 Day11(StringBuffer、排序算法)_Java

  • 代码如下

public class Test2 {
//冒泡排序:元素两两比较,大的往后放,经过一轮比较后,那么最大的元素就会出现在最后面。
public static void main(String[] args) {
int arr[] = {24, 69, 80, 57, 13};
for (int i = 0; i < arr.length - 1; i++) {
for(int j = 0 ; j < arr.length - i - 1 ; j++){
if (arr[j] > arr[j+1]) {
int tag = arr[j];
arr[j] =arr[j+1];
arr[j+1]= tag;
}
}
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}

  • 选择排序
    原理:从0索引开始,依次和后面元素比较,小的往前放,第一次完毕,最小值出现在了最小索引处
  • Java学习记录 Day11(StringBuffer、排序算法)_字符串_02

  • 代码如下

public class Test2 {
//选择排序:每次拿一个元素,跟他后面的元素,挨个去比,小的往前放,经过一轮比较后,那么最小元素就会放在最前面去
public static void main(String[] args) {
int arr[] = {24, 69, 80, 57, 13};
for (int index = 0; index < arr.length - 1; index++) {
for(int j = 1 + index; j < arr.length ; j++){
if (arr[index] > arr[j]) {
int tag = arr[index];
arr[index] =arr[j];
arr[j]= tag;
}
}
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}

  • 直接插入排序
    原理:将后面的元素,插入之前的一个有序列表,使之仍然保持有序
    代码如下

public class Test2 {
public static void main(String[] args) {
int arr[] = {24, 69, 80, 57, 13};
for (int i = 1; i < arr.length; i++) {
for (int j = i; j > 0; j--) {
if (arr[j] < arr[j - 1]) {
int tag = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = tag;
}
}
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}

  • 希尔排序
    原理:对直接插入排序的一种改进,它的思想是选择一个合适的增量,然后经过一轮插入排序后,就会让数组大致有序,然后不断的缩小增量,进行插入排序,直到增量为1,整个排序结束。第一次的增量一般取数组长度的一半
    对于增量,具有许多计算方法。其中常见的,就有克努特序列(h=1,h=3*h+1)
  • Java学习记录 Day11(StringBuffer、排序算法)_字符串_03


  • Java学习记录 Day11(StringBuffer、排序算法)_数组_04


  • Java学习记录 Day11(StringBuffer、排序算法)_Java_05


  • Java学习记录 Day11(StringBuffer、排序算法)_字符串_06


  • Java学习记录 Day11(StringBuffer、排序算法)_字符串_07


  • Java学习记录 Day11(StringBuffer、排序算法)_字符串_08

  • 代码如下

public class Test2 {
public static void main(String[] args) {
//希尔排序,是对直接插入排序的一种改进,他的思想选择一个合适的增量,然后经过一轮插入排序后,就会让数组大致有序
//然后不断的缩小增量,进行插入排序,直到增量为1 整个排序结束
int arr[] = {24, 69, 80, 57, 13};
shellSort(arr);
//其实我们的直接插入排序,就是增量为1的希尔排序

//int h = 1;
//for (int i = h; i < arr.length; i++) {
// for (int j = i; j > h - 1; j -= h) {
// if (arr[j] < arr[j - h]) {
// swapValue(arr, j, j - h);
// }
// }
//}
System.out.println(Arrays.toString(arr));
}

private static void shellSort(int[] arr) {
//定义增量为4
/* int h=4;
for (int i = h; i < arr.length; i++) {
for (int j = i; j > h - 1; j-=h) {
if (arr[j] < arr[j - h]) {
swapValue(arr, j, j - h);
}
}
}

h = 2;
for (int i = h; i < arr.length; i++) {
for (int j = i; j > h - 1; j -= h) {
if (arr[j] < arr[j - h]) {
swapValue(arr, j, j - h);
}
}
}

h = 1;
for (int i = h; i < arr.length; i++) {
for (int j = i; j > h - 1; j -= h) {
if (arr[j] < arr[j - h]) {
swapValue(arr, j, j - h);
}
}
}*/
//间隔选为4 不是很合理
/* for (int h = 4; h>0; h/=2) {
for (int i = h; i < arr.length; i++) {

for (int j = i; j > h - 1; j -= h) {

if (arr[j] < arr[j - h]) {
swapValue(arr, j, j - h);
}
}
}
}*/
//间隔得选取合理 :一般第一次的增量我们选取数组长度的一半
/* for (int h = arr.length/2; h > 0; h /= 2) {
for (int i = h; i < arr.length; i++) {

for (int j = i; j > h - 1; j -= h) {

if (arr[j] < arr[j - h]) {
swapValue(arr, j, j - h);
}
}
}
}
*/
//克努特序列
//int h=1;
//h=3*h+1; // 1,4,13,40,121,364


//我要选择一个合适的增量 使用克努特序列来选

int jianGe = 1;
while (jianGe <= arr.length / 3) {
jianGe = 3 * jianGe + 1;
}

for (int h = jianGe; h > 0; h = (h - 1) / 3) {
for (int i = h; i < arr.length; i++) {

for (int j = i; j > h - 1; j -= h) {

if (arr[j] < arr[j - h]) {
int t = arr[j];
arr[j] = arr[j - h];
arr[j - h] = t;
}
}
}
}

}
}

  • 合并排序
    原理:分而治之,递归
  • Java学习记录 Day11(StringBuffer、排序算法)_数组_09


  • Java学习记录 Day11(StringBuffer、排序算法)_数组_10


  • Java学习记录 Day11(StringBuffer、排序算法)_字符串_11

  • 代码如下

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

int arr[] = {24, 69, 80, 57, 13};
//归并排序
//分
chaiFen(arr, 0, arr.length - 1);

//归
// mergerSort(arr,0,(arr.length/2)-1,arr.length-1);

System.out.println(Arrays.toString(arr));

}

private static void chaiFen(int[] arr, int startIndex, int endIndex) {
//计算中间索引
int centerIndex = (startIndex + endIndex) / 2;
//递归来拆
if (startIndex < endIndex) {
//拆分左边
chaiFen(arr, startIndex, centerIndex);
//拆分右边
chaiFen(arr, centerIndex + 1, endIndex);
//归并
mergerSort(arr, startIndex, centerIndex, endIndex);
}
}


/**
* @param arr 要归并的数组
* @param startIndex 起始索引
* @param centerIndex 中间索引
* @param endIndex 结束索引
*/
private static void mergerSort(int[] arr, int startIndex, int centerIndex, int endIndex) {
//定义一个临时数组
int[] tempArray = new int[endIndex - startIndex + 1];
//定义临时数组的起始索引
int index = 0;
//定义左边数组的起始索引
int i = startIndex;
//定义右边数组的起始索引
int j = centerIndex + 1;
//循环比较左右两边数组的元素,往临时数组里面方法
while (i <= centerIndex && j <= endIndex) {
//进来比较
if (arr[i] <= arr[j]) {
tempArray[index] = arr[i];
i++; //记得递增索引
} else {
tempArray[index] = arr[j];
j++;//记得递增索引
}

index++; //临时数组的索引

}

//处理左边剩余元素

while (i <= centerIndex) {
tempArray[index] = arr[i];
i++; //记得递增索引
index++;
}

//处理右边剩余元素


while (j <= endIndex) {
tempArray[index] = arr[j];
j++; //记得递增索引
index++;
}

//这个时候我们的临时数组里面的元素已经排序好了

// System.out.println(Arrays.toString(tempArray));
//遍历临时数组,将临时数组中的元素,放到原数组里面去
for (int k = 0; k < tempArray.length; k++) {
arr[k + startIndex] = tempArray[k];
}


}
}

  • 快速排序
    原理:先比大小,再分区
    代码如下

public class Test2 {
public static void main(String[] args) {
int arr[] = {24, 69, 80, 57, 13};
QuickSortUtils.quickSort(arr,0,arr.length-1);
System.out.println(Arrays.toString(arr));
}
}

class QuickSortUtils {

private QuickSortUtils() {
}

/**
*
* @param arr 要排序的数组
* @param startIndex 开始索引
* @param endIndex 结束索引
*/
public static void quickSort(int[] arr,int startIndex,int endIndex){
if(startIndex<endIndex){
//找到基准数的索引
int index=getIndex(arr,startIndex,endIndex);
//对左右两边进行递归调用

quickSort(arr,startIndex,index);
quickSort(arr,index+1,endIndex);

}
}

//
//将基准数挖出形成第一个坑。
//由后向前找比他小的数,找到后挖出此数填到前一个坑中。
//由前向后找比他大或等于的数,找到后也挖出此数填到前一个坑中。
//再重复执行2,3两步骤。


//挖坑填数
private static int getIndex(int[] arr, int startIndex, int endIndex) {
//定义三个变量
int i=startIndex;
int j=endIndex;
//定义基准数
int x=arr[i];
while (i<j){
//1. 由后向前找比他小的数,找到后挖出此数填到前一个坑中。
while (i<j&&arr[j]>=x){
j--;

}
//填坑
if(i<j){
arr[i]=arr[j];
i++;//顺便让i增一下
}
//2,由前向后找比他大或等于的数,找到后也挖出此数填到前一个坑中
while (i<j&&arr[i]<x){

i++;
}

//填坑
if (i < j) {
arr[j] = arr[i];
j--; //顺便让j减一下
}


}
//以上循环完毕之后,将基准数填到最后一个坑里面去
arr[i]=x;

return i;
}
}


举报

相关推荐

Java学习-Day11

java算法题Day11

Linux学习-DAY11

java笔记Day11

【算法刷题】Day11

Python学习打卡:day11

C++学习 Day11

总结-day11

0 条评论