数据结构基础知识核心归纳(二)

数据结构基础知识核心归纳(二)

转载请声明出处：http://blog.csdn.net/andrexpert/article/details/77906004

Android                                          Java                                            数据结构
Android基础技术核心归纳(一)     Java基础技术核心归纳(一)     数据结构基础知识核心归纳(一) 
Android基础技术核心归纳(二)     Java基础技术核心归纳(二)     数据结构基础知识核心归纳(二)  
Android基础技术核心归纳(三)     Java基础技术核心归纳(三)    数据结构基础知识核心归纳(三)  
Android基础技术核心归纳(四)     Java基础技术核心归纳(四)

     不知不觉又是一年的9月，今天跟一个师弟聊天，谈到了他现在面试的一些情况，突然想起自己当年也是这么走过来的，顿时感慨良多。Android/Java经验汇总系列文章，是当初自己毕业时笔试、面试和项目开发中相关的总结，虽然不是很高深的东西，也没有归纳得很全面，但是对Android、算法、Java把握个大概还是没问题，今天特意将这些文章放出来，希望能够对看到这个系列文章的毕业生朋友一点帮助吧。当然，由于受当时知识面的限制，归纳得可能不是很准确，若有疑问就留言吧，我就不细看了。

1.冒泡排序(交换排序算法)
1.实现原理
     从 最后一个关键字开始，两两比较相邻记录的关键字，如果反序(前者大于后者)则交换，直到没有反序的记录为止，即完成一次冒泡排序，然后再依次进行相同操作，最多需 (length-1)次 冒泡排序。实质上，冒泡排序就是每次交换的结果作为下一次两两比较的基础，最终将较小的数字如同气泡般慢慢浮到上面。

2.算法实现
(1)冒泡排序功能函数

void BubbleSort(int *a,int len){
    int temp = 0;
    /*第一步：边界处理,指针变量指向null,len<0*/
     if(!a||len<0)
          return;
    /*第二步：进行n-1次冒泡排序*/
    for(int i=0;i<len-1;i++){
    /*第三步：将最后一个元素开始依次与前len-i个元素比较，反序交换*/
        for(int j=len;j>i;j--){
            if(a[j-1]>a[j]){        //完成一次交换，将较小的存放到前面
                temp = a[j-1];
                a[j-1] = a[j];
                a[j] = temp;
            }
        }
    }
}

(2)测试代码

void main(){
     int a[]={2,1,4,3,6,0,2,5,9,1};
     //计算数组的长度=sizeof(数组名)/sizeof(数组基本类型)
     //即数组所占的总字节数/单个元素占的字节数
     BubbleSort(a,sizeof(a)/sizeof(int));
}

(3)冒泡排序结果

3.算法性能分析
(1)时间复杂度：
    ◆最好情况：待排序本身有序，只需进行(n-1)次比较，没有数据移动，时间复杂度为O(n)
    ◆最坏情况：待排序逆序，需进行1+2+3+....+(n-1)=n*(n-1)/2数据移动,时间复    
      杂度为O(n^2) 
(2)空间复杂度：冒泡算法只需要一个记录的辅助空间（temp），故空间复杂度为O(1).
(3)稳定性：没有跳跃式数据交换，稳定。
2.简单选择排序
1.实现原理
     对长度为n的序列，通过(n-i)次关键字间的比较，从(n-i+1)个记录中选出关键字最小的关键字，并与第i(1≤i≤n)个记录交换。举例：有一长度n=5的序列，初始状态为{57  68  59  52  49}
首先，取第一个记录57(i=1)，通过n-i=4次比较，选出n-i+1=5个记录中最小关键字记录49，与第i=1交换;

其次，取第二个记录68(i=2)，通过n-i=3次比较，选出n-i+1个记录中最小关键字记录52，与第i=2交换;

    以此类推，最后得到的排序序列为：49 52  57  59  68 
2.算法实现
(1)代码实现

void selectSort(int *a,int len)
{
     int min,temp=0;
    /*第一步：边界处理,指针变量指向null,len<0*/
    if(!a||len<0)
         return;
     /*第二步：将第i个元素，与其他(n-i)个元素进行 比较，从(n-i+1)个元素中选出最小的并与第i个
        元素 进行交换。注意：第i个元素的下标为i-1(i>0)*/ 
     for(int i=0;i<len;i++){
          min=i;                                 //初始化min
          for(int j=i+1;j<len;j++){         //从第i+1个元素开始比较
                   if(a[min]>a[j])             //将(n-i+1)个元素中最小元素下标赋值给min
            min=j;
      }
      /*第三步：完成一次选择排序，将小标min对应最小元素与第i个元素互换*/
      if(i!=min){
           temp=a[i];
           a[i]=a[min];
           a[min]=temp;
      }
   }
}

(2)测试代码

void main(){
     int a[]={2,1,4,3,6,0,2,5,9,1};
     //计算数组的长度=sizeof(数组名)/sizeof(数组基本类型)
     //即数组所占的总字节数/单个元素占的字节数
     BubbleSort(a,sizeof(a)/sizeof(int));
}

(3)冒泡排序结果

3.算法性能分析
(1)简单选择排序最大的特点就是交换移动数据的次数相当少，最好情况交换次数为0次，最坏情况(逆序)交换次数为n-1次。对于比较次数，最好最坏的情况都是一样多，因为第i趟排序需要进行n-1次关键字的比较，因此总共需要(n-1)+(n-2)+...+1=n(n-1)/2次比较。故总的时间复杂度=(n-1)+n(n-1)/2----->即O(n^2)。
(2)空间复杂度：冒泡算法只需要一个记录的辅助空间（temp），故空间复杂度为O(1).
(3)稳定性：没有跳跃式数据交换，稳定。
3.直接插入排序
1.实现原理
     将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增1的有序表。
★举例：序列的初始状态{57,68,59,52}
    第一步：插入57到空表，此时，有序表为{57};
    第二步：插入68到有序表，68>57，插在57之后，此时有序表为{57,68}
    第三步：插入59到有序表，57<59<68，插在57和68之间，此时有序表为{57,59,68}
    第四步：插入52到有序表，52<57，插在57之前，此时有序表为{52,57,59,68}
即，直接插入排序的结果为：52 57 59 68