数据结构（第一部分）

   数据结构
                    数据结构
 数据：所有能被输入到计算机中，且被计算机处理的符号的集合。
 数据元素：数据的基本单元，由若干个数据项组成，也成为结点。
 数据项：是数据不可分割的最小单元。
 数据对象：是指相同性质，数据元素构成的集合。

数据结构：是相互之间存在一种或者多种关系的数据元素的集合。数据元素之间的关系，成为结构。

4种逻辑结构：
集合：数据元素之间，同属于一个集合。
线性：一对一关系。
树形（层次）结构：一个对多个
图状结构：多个对多个。

数据结构的存储结构：
连续存储
不连续存储

              冒泡排序

一个数组，下标从0开始依次与后一位排序，若不满足要求，就交换位置。
第一次结束后，就将最大（最小）数放置到最后的位置。
然后进行第二次比较，比较次数比上一次少一次。
public class BubbleSort {
public static int arr[]= {5,2,6,7,3};
static int n=arr.length;
public static int[] sort(int[] arr) {
for(int i=0;i<n-1;i++) {
for(int j=0;j<n-1-i;j++) {
if(arr[j]>arr[j+1]) {
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
return arr;
}
public static void main(String[] args) {
sort(arr);
for (int name : arr) {
System.out.print(name+"\t");
}
}
}
插入排序
小规模排序，并且有部分已经排序，插入排序比冒泡排序更加有效率。

时间复杂度：若要通过使用插入排序排序大小为n的列表，需要执行（n-1）次。
最佳用例：每个通道仅需要一次比较，时间复杂对为O(n);
最差用例：每个通道需要进行1次，2次，3次……时间复杂度为O(n2)。

方法：将列表分为俩个子列表，左边是已经排序的列表，右边为为排序列表。
通道1（第一次循环）：将未排序的列表的第一个元素放置在排序列表的正确位置。
内循环
通道2：将未排序的列表第一个元素放置在排序列表的正确位置。

程序：
public class InsertSort {
public static int arr[]= {70,80,30,10,20};
public static int n=arr.length;
public static int[] sort(int []arr) {
for(int i=1;i<n;i++) {
int temp=arr[i];//设置temp设置临时的需要比较的数据
int j=i-1;//j用于存放排序好的数组元素
while(j>=0&&arr[j]>temp) {
arr[j+1]=arr[j];//将索引j处的值移动到j+1处
j–;
}
arr[j+1]=temp;
}
return arr;
}

public static void main(String[] args) {
   InsertSort insertSort=new InsertSort();
   insertSort.sort(arr);
   for (int name : arr) {
       System.out.print(name+"\t");
   }
}

}
选择排序
选择排序的原理;每一趟从待排序的记录中选出最小的元素，顺序放在已排好序的序列最后，直到全部记录排序完毕
public class SelectedSort {
public static void main(String[] args) {
int [] arr= {1,3,5,2,4};
for(int i=0;i<arr.length-1;i++) {
int k=i;
for(int j=k+1;j<arr.length;j++) {
if(arr[j]<arr[k]) {
k=j;//记录最小值的位置
}
}
if(i!=k) {//交换位置
int temp=arr[i];
arr[i]=arr[k];
arr[k]=temp;
}
}
for (int i : arr) {
System.out.print(i+"\t");
}
}
}

                高级排序

桶排序：
稳定排序，最快的排序，但是及其消耗空间，以空间换时间。
桶排序中：无序数组有个要求，成员隶属于固定的区间。（如范围为0到9）

  数组的长度为多少，就需要构造多少个“桶”。
  将待排的数据选出来，放入编号相同的空桶中。

  时间复杂度：桶排序做到了线性时间复杂度。O(M+N)（M为数据输入条数。N为数据输出条数）
              如果使用多次桶排序，时间复杂度为O(p(M+N))。
  空间复杂度：O(n)
 
  程序：
  public class TestBucket {
public static void main(String[] args) {
   int[] x= {6,2,4,1,5,9};
   int[] sorted=bucketSort(x,10);
   for(int i=0;i<sorted.length;i++) {
       if(sorted[i]>0) {
          System.out.print(sorted[i]+"\t");
       }
   }
}

private static int[] bucketSort(int[] nums, int maxNum) {
   //nums:待排数组           maxNum：空桶长度
   //空桶数组
   int[] sorted=new int[maxNum+1];
   //实现算法
   for(int i=0;i<nums.length;i++) {
       sorted[nums[i]]=nums[i];
   }
   return sorted;
}

}