时间复杂度
| 有序数组 | 无序数组 | |
|---|---|---|
| 增 | n/2+ log2n l o g 2 n | 1 |
| 删 | n/2+ log2n l o g 2 n | N |
| 改 | log2n l o g 2 n | N/2 |
| 查 | log2n l o g 2 n | N/2 |
| 插入 | n/2+ log2n l o g 2 n | N/2 |
在查找比较频繁的情况下，可以考虑使用有序数组，其它情况一律使用无序数组。
数组共有的缺点是插入比较慢，删除比较慢，新增时无序快，有序慢。然后大小固定。
链表查找指定位置的元素，时间复杂度为n/2，查找指定元素也是n/2.
数组查找指定位置的元素，时间复杂度为常量1，查找指定元素为n/2.
查找的话，看是根据位置查找，还是根据元素查找，后者的话，二种方式差距不大。
数组删除指定位置的元素，时间复杂度为n/2，删除指定元素为n
链表删除指定位置的元素，时间复杂度为n/2，删除指定元素为n/2.
但是这两个虽然都是n/2，但是链表的删除更快，因为链表只需要找到元素，移除就行了，而数组是要移动后面的元素的。所以链表的删除更快，但是如果一直都是删除末尾的元素的话，数组比链表好用。
插入的话，同删除一样。
修改的话，数组有绝对优势。当然，如果是根据元素修改而不是指定位置，二者差别不大（数组还是占优）。
下面是排序算法：
冒泡排序
public static void maoPaoSort(int[] array){
for (int i=array.length-1;i>1;i--){
for (int j=0;j<i;j++){
if (array[j]>array[i]){
int temp=array[j];
array[j]=array[i];
array[i]=temp;
}
}
}
} 仿冒泡：
public void maoPaoSort(int[] array){
for (int i=0;i<array.length-1;i++){
for (int j=i+1;j<array.length;j++){
if (array[j]<array[i]){
int temp=array[j];
array[j]=array[i];
array[i]=temp;
}
}
}
}
`
选择排序是冒泡排序的一个改进，一般来说选择排序的速度比冒泡排序要快，因为它的交换字数更少。它们的时间复杂度是一样的。
public static void xuanZeSort(int[] array){
for (int i=array.length-1;i>1;i--){
int bigger=i;
for (int j=0;j<i;j++){
if (array[j]>array[bigger]){
bigger=j;
}
}
swap(array,i,bigger);
}
}插入排序是比冒泡排序和选择排序更快的一种算法，实现也复杂一些。
public static void chaRuSort(int[] array){
for (int i=1;i<array.length;i++){
int temp=array[i];
int j=i;
while (j>0&&array[j-1]>temp){
array[j]=array[j-1];
j--;
}
array[j]=temp;
}
}
递归版插入排序：
public static void insertSortRecursion(int[] array,int n){
int temp=array[n];
int i=n;
for (;i>0;i--){
if (array[i-1]>temp){
array[i]=array[i-1];
}else {
break;
}
}
array[i]=temp;
}
public static void diguiChaRuPaiXu(int[] array,int n){
if (n<array.length){
insertSortRecursion(array,n);
diguiChaRuPaiXu(array,n+1);
}
}
public static void main(String[] args) {
Random random=new Random(47);
int array[]=new int[10];
for (int i=0;i<array.length;i++){
array[i]=random.nextInt();
}
diguiChaRuPaiXu(array,0);
// guiBing(array,0,array.length-1);
//intSortGuiBing(array,0,0,1);
for (int a:array){
System.out.print(a+"__");
}
}
结果：
-2076178252__-2014573909__-1812486437__-1172028779__-1128074882__229403722__688081923__809509736__1717241110__1791060401__希尔排序：它是插入排序的升级版
特点是在最好与最坏的情况下，时间复杂度都差不多，也就是稳定。他比冒泡，插入、选择排序都要快些。不如快速排序。
public class Xier {
public static void main(String[] args) {
ArraySh arraySh=new ArraySh(10);
Random random=new Random();
for (int i=0;i<10;i++){
arraySh.insert(random.nextInt());
}
arraySh.display();
arraySh.shellSort();
arraySh.display();
}
}
class ArraySh{
private long[] theArray;
private int nElems;
public ArraySh(int max){
theArray=new long[max];
nElems=0;
}
public void insert(long value){
if (nElems==theArray.length){
return;
}
theArray[nElems]=value;
nElems++;
}
public void display(){
System.out.println("A=");
for (int j=0;j<nElems;j++){
System.out.println(theArray[j]+" ");
}
System.out.println(" ");
}
public void shellSort(){
int inner,outer;
int h=1;
long temp;
while (h<nElems/3){
h=h*3+1;
}
while(h>0){
for (outer=h;outer<nElems;outer++){
temp=theArray[outer];
inner=outer;
while (inner>h-1 && theArray[inner-h]>=temp){
theArray[inner]=theArray[inner-h];
inner-=h;
}
theArray[inner]=temp;
}
h=(h-1)/3;
}
}
}
归并排序法（时间复杂度nlogn）：
public static void main(String[] args) {
Random random=new Random(47);
int array[]=new int[3];
for (int i=0;i<array.length;i++){
array[i]=random.nextInt();
}
guiBing(array,0,array.length-1);
//intSortGuiBing(array,0,0,1);
for (int a:array){
System.out.print(a+"__");
}
}
结果：
-2014573909__-1172028779__1717241110__
public static void guiBing(int[] array,int start,int end){
if (start>=end)
return;
int boundary=(start+end)/2;
guiBing(array,start,boundary);
guiBing(array,boundary+1,end);
intSortGuiBing(array,start,boundary,end);
}
/**
* 排序数组
* @param array 待排序数组
* @param array1Start 有序部分1的起始位置
* @param endAndStart 有序部分1的终止位置，也是有序部分2 的起始位置
* @param array2End 有序部分2的终止位置
*/
public static void intSortGuiBing(int[] array, int array1Start, int endAndStart, int array2End){
int len1=endAndStart-array1Start+1;
int len2=array2End-endAndStart;
int[] array1= new int[len1];
int[] array2= new int[len2];
//复制数组
for (int i=array1Start;i<=array2End;i++){
if (i<=endAndStart){
array1[i-array1Start]=array[i];
}
else {
array2[i-endAndStart-1]=array[i];
}
}
int temp1=0;
int temp2=0;
//合并数组
while (array1Start<=array2End){
if (temp1<len1 && temp2<len2 ) {
if (array1[temp1]<=(array2[temp2]))
array[array1Start++] = array1[temp1++];
else
array[array1Start++] = array2[temp2++];
}
else if (temp1==len1){
array[array1Start++] = array2[temp2++];
}
else {
array[array1Start++] = array1[temp1++];
}
}
}快速排序法
算法思想：基于分治的思想，是冒泡排序的改进型。首先在数组中选择一个基准点，然后分别从数组的两端扫描数组，设两个指示标志（lo指向起始位置，hi指向末尾)，首先从后半部分开始，如果发现有元素比该基准点的值小，就交换lo和hi位置的值，然后从前半部分开始扫秒，发现有元素大于基准点的值，就交换lo和hi位置的值，如此往复循环，直到lo>=hi,然后把基准点的值放到hi这个位置。一次排序就完成了。以后采用递归的方式分别对前半部分和后半部分排序，当前半部分和后半部分均有序时该数组就自然有序了。
public void kuaiSuSort(int[] arrary,int lef,int right){
if (lef>=right)
return;
int cutOff=fenge(arrary,lef,right);
kuaiSuSort(arrary,lef,cutOff-1);
kuaiSuSort(arrary, cutOff+1,right);
}
public int fenge(int[] array,int lef,int right){
int temp=array[lef];
while (lef<right){
while (array[right]>=temp && lef<right){
right--;
}
array[lef]=array[right];
// array[right]=temp;
while (array[lef]<=temp && lef<right){
lef++;
}
array[right]=array[lef];
}
array[lef]=temp;
return right;
}快速排序在序列中元素很少时，效率将比较低.
三向切分快速排序法，适合重复元素多的数组：
public static void sanXiang(int[] array,int left,int right){
if (left>=right){
return;
}
int begin=left;
int end=right;
int temp=left+1;
int tempValue=array[left];
while (temp<=right){
if (array[temp]>tempValue){
int tt= array[right];
array[right--]=array[temp];
array[temp]=tt;
}
else if (array[temp]<tempValue){
int tt=array[left];
array[left]=array[temp];
array[temp]=tt;
left++;
temp++;
}
else {
temp++;
}
}
sanXiang(array,begin,left);
sanXiang(array,right+1,end);
}
719
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
