数据结构

查找

二分查找：二分查找算法是在有序数组中用到的较为频繁的一种算法，在未接触二分查找算法时，最通用的一种做法是，对数组进行遍历，跟每个元素进行比较，其时间为O(n).但二分查找算法则更优，因为其查找时间为O(lgn)，譬如数组{1， 2， 3， 4， 5， 6， 7， 8， 9}，查找元素6，用二分查找的算法执行的话，其顺序为：
    1.第一步查找中间元素，即5，由于5<6，则6必然在5之后的数组元素中，那么就在{6， 7， 8， 9}中查找，
    2.寻找{6， 7， 8， 9}的中位数，为7，7>6，则6应该在7左边的数组元素中，那么只剩下6，即找到了。

public static int binarysearch(int value,int size){

int middle = 0;

int low = 0;

int pow = size;

while(low>pow)){

middle = (low + pow)/2;

if(arr[middle] == value){

return middle;

}else if (arr[middle]>value) {

pow = middle;

}else if{

pow = middle;

}

}

return -1;

}

 

排序

1 冒泡排序：把最小的往上冒，就像冒泡一样的。

大的往后冒泡

1比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在第一趟，最后的元素应该会是最大的数。

3针对所有的元素重复以上的步骤，除了最后一个。

public void sort(int[] a)

    {int temp = 0;

        for (int i = a.length - 1; i > 0; --i)

        {

            for (int j = 0; j < i; ++j)

            {

                if (a[j] > a[j+1])

                {

                    temp = a[j];

                    a[j] = a[j + 1];

                    a[j + 1] = temp;

                }

            }

        }

    }

2 选择排序

设数组为a[0…n-1]。

1. 初始时，数组全为无序区为a[0..n-1]。令i=0

2. 在无序区a[i…n-1]中选取一个最小的元素，将其与a[i]交换。交换 之后a[0…i]就形成了一个有序区。

3.i++并重复第二步直到i==n-1。排序完成。

void Selectsort(int a[], int n)  

{  

    int  minIndex;  

    for (int i = 0; i < n; i++)  //找无序数组最小数的次数

    {  

        minIndex = i; //找最小元素的位置  

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

            if (a[j] < a[minIndex])  

                minIndex = j;  

     if(minIndex!=i){

       //如果不是无序区的最小值位置不是默认的第一个数据，则交换之。

         temp=a[i];

         a[i]=a[minIndex];

         a[minIndex]=temp;

     }

    }  

}

 

3 插入排序 ：可以很清楚的发现，选择排序是固定位置，找元素。相比于插入排序的固定元素找位置，是两种思维方式。

设数组为a[0…n-1]。

1.      初始时，a[0]自成1个有序区，无序区为a[1..n-1]。令i=1

2.      将a[i]并入当前的有序区a[0…i-1]中形成a[0…i]的有序区间。

3.      i++并重复第二步直到i==n-1。排序完成。

 

private static void insertSort(int[] arr, int n) {

for (int i = 1; i < n; i++) {   //每次从无序数组中取出一个数

for (int j = i-1; j >= 0; j--) { //把取出的数放到有序数组相应的位置

if (arr[j] > arr[j+1]) {

int temp = arr[j+1];

arr[j+1] = arr[j];

arr[j] = temp;

}

}

}

}

 

4：快速排序

对挖坑填数进行总结

1．i =L; j = R; 将基准数挖出形成第一个坑a[i]。

2．j--由后向前找比它小的数，找到后挖出此数填前一个坑a[i]中。

3．i++由前向后找比它大的数，找到后也挖出此数填到前一个坑a[j]中。

4．再重复执行2，3二步，直到i==j，将基准数填入a[i]中。

static void quick_sort(int s[], int l, int r)

{

    if (l < r)

    {

        int i = l, j = r, x = s[l];

        while (i < j)

        {

            while(i < j && s[j] >= x) // 从右向左找第一个小于x的数

j--;  

            if(i < j) 

s[i++] = s[j];

            while(i < j && s[i] < x) // 从左向右找第一个大于等于x的数

i++;  

            if(i < j) 

s[j--] = s[i];

        }

        s[i] = x;

        quick_sort(s, l, i - 1); // 递归调用 

        quick_sort(s, i + 1, r);

    }

}