数据结构和算法

数据结构是计算机储存，组织数据的方式

算法是一系列规定的计算步骤，为了实现特定的计算目的。

二分搜素(基于有序数组)

从数组中间元素开始，如果中间元素正好是x，而查找成功

否则我没利用中间位置建数组分为前，后两个子数组

如果x小于中间位置的元素，则进一步查找前一个子数组

否则进一步查找后一个子数组

重复以上步骤，直到找到满足条件的元素，或直到子数组不存在为止，代表查找不成功，

二分查找java实现

复杂度分析

n/2，n/4，n/8，。。。，n/2^k

n/2^k=1

2^k=n

k=logN

时间复杂度：时间增长的趋势，

2^k=n

k=logN

O(logN)

int i=1;
while(i<n){
i=i*2；
}

O(nlogN）

for(int i=0;i<=n;i++){
int i=1;
while(i<n){
i=i*2；
}
}

O(n2)

for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
x++;
}
}

O(nm)

for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
x++;
}
}

空间复杂度：内存空间增长的趋势

O(1)

int x=0;

int y=0;

x++;

y++;

O(n)

int[]  newArray=new int[n];
for(int i=0;i<n;i++){
newArray[i]=i;
}

时间空间复杂度=时间和空间增长的趋势

排序算法

插入排序 lnsertion Sort

快拍 Quick Sort

归并排序 Merge Sort

插入排序：

在插入排序中，我们从前到后依次处理未排好序的元素，对于每

个元素，我们将它与之前排好序的元素进行比较，找到对应的位

置后并插入。

步骡

1.从第二个元素（第一个要被排序的新元素）开始，从后向前扫描之前的元素序列

2.如果当前扫描的元素大于新元素，将扫描元素移动到下一位

3.重复步骤2，直到找到一个小于或者等于新元素的位置

4.将新元素插入到该位置，

5,对于之后的元素重复步骤1~4

Java代码

public void insertionSort(int[]array){

for(int i =1;i

int cur =array[i];

int insertionlndex =i-1;

while(insertionlndex >=0&&array[insertionlndex]>cur){

array[insertionlndex +1]=array[insertionlndex];

insertionlndex--;

}

array[insertionlndex+1]=cur;

}

}

快排QyuickSort

快排是一种分治算法，在这种算法中，我们把大问题变成小问题，然后将小问题逐个解决，当小问题解决完时，大问题也迎刃而解。

选取一个目标元素，然后将目标元素放到数组中正确的位置。然

后根据排好序后的元素，将数组切分为两个子数组，用相同的方

法，在没有排好序的范围使用相同的操作。

步骤

1.对于当前的数组，取最后一个元素当做基准数(pot)

2.将所有比基准数小的元素排到基准数之前，比基准数大的排在基准数之后

3.当基准数被放到准确的位置之后，根据基数数的位置将元素切分为前后两个子数组

4.对子数组采用步骤1~4的递归操作，直到子数组的长度小于等于1为止

public void quickSort(int[]array,int left,int right){

if(left >=right)return;

int partitionlndex partition(array,left,right);

quickSort(array,left,partitionlndex-1);

quickSort(array,partitionlndex+1,right);

}

public int partition(int[]array,int left,int right){

int pivot array[right];

int leftIndex= left;

int rightindex =right-1;

while(true){

while(leftlndex< right& array[leftlndex]

leftlndex++;

while(rightlndex >=left &array[rightlndex]>pivot){

rightlndex--;

if(leftlndex >rightlndex)break;

swap(array,leftlndex,rightlndex);

}

swap(array,leftIndex,right);//swap pivot to the right position

return leftIndex;

}

public void swap(int[]array,int left,int right){

int temp =array[left];

array[left] =array[right];

array[right] =temp;

}

复杂度分析

时间复杂度：O(n^2),平均时间复杂度：O(nlogN)

空间复杂度：O(n),平均空间复杂度：O(logN)

归并排序

在此算法中，我们将一个数组分为两个子数组，通过递归重复将数组切

分到只剩下一个元素为止。然后将每个子数组中的元素排序后合并，通

过不断合并子数组，最后就会拿到一个排好序的大数组。

归并排序和快排一样，也是一种分而治之算法，简单理解就是将大问题变为小问题，然后

把所有小问题都解决掉，大问题就迎刃而解了。其中主要包括两个步骤：

1.切分步骤：将大问题变为小问题，通过递归解决更小的子问题。

2.解决步骤：将小问题的结果合并，以此找到大问题的答案。

具体步骤

1.递归切分当前数组

2.如果当前数组数量小于等于1，无需排序，直接返回结果

3.否则将当前数组分为两个子数组，递归排序这两个子数组

4.在子数组排序结束后，将子数组的结果归并成排好序的数组

public void merge(int[]array,int[]helper,int left,int mid,int right){

for(int i = left;i

helper[i]=array[i];

}

int leftStart= left;

int rightStart= mid 1;

for (int i=left;i

if (leftStart >mid){

array[i]=helper[rightStart++];

}else if (rightStart >right){

array[i]=helper[leftStart++];

}else if (helper[leftStart]

array[i]=helper[leftStart++];

}else{

array[i]=helper[rightStart++];

}

}

}