JAVA数据结构和算法---数组及排序算法

一、常用数据结构

  1. 数组Array:无序查数组找慢,插入快;有序数组查找快,插入/删除慢;大小固定,存储单一元素
  2. 栈Stack:先进后出
  3. 队列Queue:先进先出
  4. 链表Linked List:插入/删除快;查找慢
  5. 树Tree :二叉树、红黑树、2-3-4树
  6. 哈希表Hash
  7. 堆Heap:对最大项数据存取快
  8. 图Graph

二、数组Array

1.只能存储单一类型的数据

1.数组声明、初始化、查询遍历

//声明长度为3的数组myArray,存放int类型,并初始化
int [] myArray = new int[3];
myArray[0] = 1;  
System.out.println(myArray[0]);
//声明值为{1,2,3}的数组myArray
int [] myArray = {1,2,3};
for(int i = 0; i < myArray.length; i++){
    System.out.println(myArray[i]);
}

2.数组的增删改—一般不用数组
1)增加:查找到需要增加的位置索引,所有值向后移动
2)删除:查找到需要删除的位置索引,所有值向前移动
3)修改:查找到需要修改的位置索引,替换

三、排序算法

1.冒泡排序
【1】基本原理
①比较相邻的元素。如果第一个比第二个大,就交换他们两个。
②对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数(也就是第一波冒泡完成)。
③针对所有的元素重复以上的步骤,除了最后一个。
④持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
在这里插入图片描述

【2】代码

public class BubbleSort {    
  public static int[] sort(int[] array){        
    //这里for循环表示总共需要比较多少轮        
    for(int i = 1 ; i < array.length; i++){            
    //设定一个标记,若为true,则表示此次循环没有进行交换,也就是待排序列已经有序,排序已经完成。            
    boolean flag = true;            
    //这里for循环表示每轮比较参与的元素下标            
    //对当前无序区间array[0......length-i]进行排序            
    //j的范围很关键,这个范围是在逐步缩小的,因为每轮比较都会将最大的放在右边            
    for(int j = 0 ; j < array.length-i ; j++){                
        if(array[j]>array[j+1]){                    
            int temp = array[j];                    
            array[j] = array[j+1];                    
            array[j+1] = temp;                    
            flag = false;                
        }            
       }            
       if(flag){                
           break;            
           }            
       //第 i轮排序的结果为            
       System.out.print("第"+i+"轮排序后的结果为:");          
       display(array);                     
       }        
       return array;             
  }         
  //遍历显示数组    
  public static void display(int[] array){        
      for(int i = 0 ; i < array.length ; i++){          
          System.out.print(array[i]+" ");        
      }        
      System.out.println();    
  }         
  public static void main(String[] args) {        
      int[] array = {4,2,8,9,5,7,6,1,3};        
      //未排序数组顺序为        
      System.out.println("未排序数组顺序为:");        
      display(array);        
      System.out.println("-----------------------");        
      array = sort(array);        
      System.out.println("-----------------------");          
      System.out.println("经过冒泡排序后的数组顺序为:");        
      display(array);    
    } 
}

【3】时间复杂度:两层循环O(n^2)
2.选择排序
【1】基本思想
①从待排序序列中,找到关键字最小的元素
②如果最小元素不是待排序序列的第一个元素,将其和第一个元素互换
③从余下的 N - 1 个元素中,找出关键字最小的元素,重复(1)、(2)步,直到排序结束
在这里插入图片描述
【2】代码

 public static int[] sort(int[] array){        
   //总共要经过N-1轮比较        
   for(int i = 0 ; i < array.length-1 ; i++){            
       int min = i;            
       //每轮需要比较的次数            
       for(int j = i+1 ; j < array.length ; j++){                
           if(array[j]<array[min]){                    
               min = j;
              //记录目前能找到的最小值元素的下标                
           }            
       }            
   //将找到的最小值和i位置所在的值进行交换            
   if(i != min){                
       int temp = array[i];                
       array[i] = array[min];                
       array[min] = temp;            
   }            
 }        
 return array;   
}

【3】时间复杂度:O(n*2)
3.直接插入排序
【1】基本思想
每一步将一个待排序的记录,插入到前面已经排好序的有序序列中去,直到插完所有元素为止。
在这里插入图片描述
【2】代码

public static int[] sort(int[] array){        
    int j;        
    //从下标为1的元素开始选择合适的位置插入,因为下标为0的只有一个元素,默认是有序的        
    for(int i = 1 ; i < array.length ; i++){            
        int tmp = array[i];
        //记录要插入的数据            
        j = i;            
        while(j > 0 && tmp < array[j-1]){
        //从已经排序的序列最右边的开始比较,找到比其小的数                
            array[j] = array[j-1];//向后挪动                
            j--;            
        }            
        array[j] = tmp;
        //存在比其小的数,插入        
    }        
return array;    
}

【3】时间复杂度:O(n*2)

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页