ICode9

精准搜索请尝试: 精确搜索
首页 > 其他分享> 文章详细

数组八大运算

2022-05-20 11:31:22  阅读:132  来源: 互联网

标签:index arr 八大 运算 int ++ 数组 排序


数组八大运算

1;冒泡排序

2;选择排序

3;直接插入排序

4;希尔排序

5;快速排序

6;归并排序

7;基数排序

8;堆排序

 

一  冒泡排序

原理;数组元素两两比较,交换位置,大元素向后放。那么经过一轮比较后做大的元素会出现在最大索引处

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


//定义一个数组
int[] arr = {14, 10, 30, 32, 71, 51, 23, 40, 99};



for (int j = 0; j < arr.length-1; j++) {//循环次数
for (int i = 0; i < arr.length-1-j; i++) {遍历数组
if(arr[i]>arr[i+1]){
//定义一个中间交换量,交换位置
int t = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = t;
}

}

}
二 选择排序

原理;从0索引开始,依次和后面的元素进行比较,小的元素往前放,经过一轮比较后,最小的元素出现在最小索引处

//定义一个数组
int[] arr = {14, 10, 30, 32, 71, 51, 23, 40, 99};


for (int j = 0; j < arr.length-1; j++) {//循环次数

for (int i = 1+j; i < arr.length; i++) {//遍历数组
if (arr[j] > arr[i]) {//排序思路
int t = arr[j];
arr[j] = arr[i];
arr[i] = t;
}

}
}
三 直接插入排序
思路;将一个元素插入到一个长度为m的有序表中,使他仍保持顺序

方法一

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


//定义一个数组
int[] arr = {14, 10, 30, 32, 71, 51, 23, 40, 99};

//外层循环定义轮次
for (int i = 1; i < arr.length; i++) {
//里曾循环进行比较插入
int j=i;
while(j>0&&arr[j]<arr[j-1]){
int t =arr[j];
arr[j]=arr[j-1];
arr[j-1]=t;
j--;

}
}
方法二
//定义一个数组
int[] arr = {14, 10, 30, 32, 71, 51, 23, 40, 99};

//外层循环定义轮次
for (int i = 1; i < arr.length; i++) {
//里曾循环进行比较插入

for(int j =i;j>0;j--){
if(arr[j]<arr[j-1]){
int t =arr[j];
arr[j]=arr[j-1];
arr[j-1]=t;

}
}
}
四  希尔排序
又称缩小增量排序

基本思想;先将原表按增量ht分组,每个子文件按照直接插入法排序,
同样下一个增量ht/2将文件在分为子文件,在直接插入法排序。直到ht等于1时整个文件拍好。
关键;选择合适的增量。
插入排序时增量为1的希尔排序。

//第一次增量可以选取数组长度的一半.克鲁特序列更高效。



//定义一个数组
int[] arr = {14, 10, 30, 32, 71, 51, 23, 40, 99};

//克努特序列,希尔排序的最佳增量
int jiange =1;
while(jiange<=arr.length/3){//如果间隔数小于等于数组长度的3/1,克努特序列成立,定义循环
jiange=jiange*3+1;
}

//三重for循环
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) {//比较循环,间隔为h
if(arr[j]<arr[j-h]){//比较方法体
int t =arr[j];
arr[j]=arr[j-1];
arr[j-1]=t;
}

}

}

}


五 快速排序
分治法;比大小,在区分
1;重数组中去出一个数,作为基准数
2;分区;将比这个数大或者等于的数都放在右边小于的放在左边。
3;重复左右区间的分区,直到各个区间只有一个数
public class Demo1 {
public static void main(String[] args) {

//定义一个数组
int[]arr={10,3,5,6,2,0,200,40,50,8};
//调用工具类,进行快速排序,传入起始位置,传入结束位置
Outer.quickSort(arr,0, arr.length-1);
//输出结果
System.out.println(Arrays.toString(arr));

}
}





public class Outer {
//快速排序
public static void quickSort(int[] arr, int start, int end) {
//找出分左右两区的索引位置,然后对左右两区进行递归调用

if (start < end) {
int index = getIndex(arr, start, end);
quickSort(arr, start, index - 1);
quickSort(arr, index + 1, end);
}

}

private static int getIndex(int[] arr, int start, int end) {
int i = start;
int j = end;
int x = arr[i];
while (i<j){

//由后向前找比他小的数,找到后挖出这个数填到前一个坑中
while (i < j && arr[j] >= x) {
j--;
}
if (i < j) {
arr[i] = arr[j];
i++;
}

//由后向前找比他大或者等于的数,找到后挖出这个数填到前一个坑中
while (i < j && arr[i] < x) {
i++;
}
if (i < j) {
arr[j] = arr[i];
j--;
}
}
arr[i] = x;
return i;
}
}
六 数组排序之归并排序
思路;假设初始序列由n个记录,则可以看成n个有序子序列,每一个子序长度为一,然后凉凉归并
得到n/2个长度为2或者一的有序子序列,在两两归并,直到得到一个长度为n的有序序列为止。

       //原始待排数组
//int [] arr={10,30,2,1,0,8,7,5,19,29};

//我们先给一个左右两边时有序的一个数组,先来进行归并操作

int[] arr ={4,5,7,8,1,2,3,6};
//拆分

//归并
guiBing(arr,0,3,arr.length-1);
//
}

private static void guiBing(int[] arr,int startIndex,int centerIndex,int endIndex){
//定义一个临时数组接受数据
int[] tempArr =new int[endIndex-startIndex+1];
//定义左边数组起始索引
int i =startIndex;

//定义右边数组的起始长度
int j =centerIndex+1;
//定义临时数组的起始索引
int index =0;
//比较两边数组元素大小,往临时数组放
while(i<=centerIndex&&j<=endIndex){
if(arr[i]<=arr[j]){
tempArr[index] =arr[i];
i++;
}else {
tempArr[index]=arr[j];
j++;
}
index++;
}
//处理剩余元素
while(i<=centerIndex){
tempArr[index]=arr[i];
i++;
index++;
}
while (j<=endIndex){
tempArr[index] =arr[j];
j++;
index++;
}
System.out.println(Arrays.toString(tempArr));
}
}

七;基数排序
通过分配在收集的方式进行排序

public class Outer {

public static void main(String[] args) {
//基数排序。通过分配在收集的方式进行排序
int[] arr ={2,1,5,21,31,444,23,33,47,10,903,124,987,100};
//确定排序轮次
//获取数组中的最大值
// int max =getMax(arr);

sortArrary(arr);

//输出排序后的数组
// System.out.println(Arrays.toString(arr));

}

private static void sortArrary(int[] arr) {
//定义二维数组,放十个桶。
int[][] tempArr=new int[10][arr.length];
//定义一维数组,统计数组
int[] counts =new int[10];
int max =getMax(arr);
int len = String.valueOf(max).length();
//循环轮次
for (int i = 0,n=1; i < len; i++,n*=10) {
for (int j = 01;j < arr.length; j++ ) {

//获取每个位上的数字
int ys = arr[j]/n%10;
tempArr[ys][counts[ys]++]=arr[j];
}
//取出桶中元素
int index =0;
for (int k = 0; k < counts.length; k++) {
if(counts[k]!=0){
for (int h = 0; h < counts[k]; h++) {
//桶中取出元素放回原数组
arr[index]=tempArr[k][h];
index++;
}
counts[k]=0;//清除上一位
}

}
}
}

private static int getMax(int[] arr) {
int max =arr[0];
for (int i = 1; i < arr.length; i++) {
if(arr[i]>max){
max=arr[i];
}

}
return max;
}
}

八 堆排序
思想;1;将待排序的序列造成一个大顶堆,此时整个序列最大值就是顶堆的根节点
2;将其末尾元素进行交换,此时末尾就是最大值
3;然后将n-1个元素重新构造成一个堆。这样会得到n个元素的次小值
4;如此反复,得到有序序列


public class Outer {

public static void main(String[] args) {
//定义一个数组
int []arr ={1,0,6,7,2,3,4};
//调整成为顶堆的方法
//定义开始调整的位置
int startIndex=(arr.length-1)/2;
//循环开始
for(int i =startIndex;i>=0;i--){
toMaxHeap(arr,arr.length,i);
}
System.out.println(Arrays.toString(arr));
}
private static void toMaxHeap(int[] arr,int size,int index){
//获取左右字节
int leftNodeIndex=index*2+1;
int rightNodeIndex=index*2+2;
//查找最大节点
int maxIndex=index;
if(arr[leftNodeIndex]>arr[maxIndex]&&leftNodeIndex<size){
maxIndex=leftNodeIndex;
}
if(arr[rightNodeIndex]>arr[maxIndex]&&rightNodeIndex<size){
maxIndex=rightNodeIndex;
}
//我们来调换位置
if(maxIndex!=index){
int t= arr[maxIndex];
arr[maxIndex] =arr[index];
arr[index]=t;
//调换完之后可能会影响到下面的子树不是大顶堆,我们还需要再次调换
toMaxHeap(arr,size,maxIndex);
}
}
}





标签:index,arr,八大,运算,int,++,数组,排序
来源: https://www.cnblogs.com/xyzaa/p/16291724.html

本站声明: 1. iCode9 技术分享网(下文简称本站)提供的所有内容,仅供技术学习、探讨和分享;
2. 关于本站的所有留言、评论、转载及引用,纯属内容发起人的个人观点,与本站观点和立场无关;
3. 关于本站的所有言论和文字,纯属内容发起人的个人观点,与本站观点和立场无关;
4. 本站文章均是网友提供,不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属;如您发现该文章侵犯了您的权益,可联系我们第一时间进行删除;
5. 本站为非盈利性的个人网站,所有内容不会用来进行牟利,也不会利用任何形式的广告来间接获益,纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

专注分享技术,共同学习,共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有