Java数据结构与算法

算法:    排序算法的基本算法(三种)

冒泡:(每轮排序获取到一个最大值,所以每轮减去排序的次数,-1是防止越界)

    每相邻的两个数据比较,如果第一个比第二个大,就交换

  public  staticvoid bubbleSort(int []datas){

       for (int i = 0; i <datas.length-1;i++) {//排序的次数

           for (int j = 0; j<datas.length-i-1; j++) {//每轮的比较

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

                  int temp=datas[j];

                  datas[j]=datas[j+1];

                  datas[j+1]=temp;

              }

           }

       }

    }

选择 :(中)

遍历所有数据找到最小数据的下标,遍历到的数据和最小下标数交换

publicstaticvoid selectSort(int[] datas) {

    for (int i = 0; i < datas.length - 1; i++) {

       int min = i;//内循环获取最小数的下标,第一次默认最小的i

       for (int j = i + 1; j < datas.length; j++) {//忽略比较过的值

          if (datas[min] > datas[j]) {

              min= j;  

           }

       }//将最小数据和遍历到的数交换位置

       int temp = datas[i];

       datas[i] = datas[min];

        datas[min]= temp;

    }

}

插入:(高)

从第二个数据开始依次向前比较.如果发现比自己大,该大的往后瞬移,将大的数插入到他本身的后面;

publicstaticvoid insertSort(int datas[]) {

  int i=0;//第二个数开始遍历

  int j=0;

    for (i = 1; i < datas.length; i++) {

       int temp = datas[i];//向前比较

       for (j = i - 1; j >= 0; j--) {

          if (datas[j] > temp) {//比较到大的数据就后移

              datas[j+ 1] = datas[j];

           }else { 

             break;

           }                                                                            

       }

       //判断 j == -1 或者 就是第一个小于等于temp数据的位置

       datas[j + 1] = temp;

    }

}

快速排序算法:

publicstaticvoid quickSort(int datas[], int start,int end) {

       if (start >= end) {

           return;

       }else {

           int middle =findMiddle(datas, start,end);

           quickSort(datas, start, middle- 1);

           quickSort(datas, middle + 1,end);

       }

    }

    privatestaticint findMiddle(int datas[],int start,int end) {

       int temp = datas[end];//参照物

       int left = start - 1;

       int right = end;

       while (true) {

           // 1.从左边依次找数据，找到第一个比参照大的数据

           while (++left < end && datas[left]<= temp);   

           if (left == end) {

              //参照物是最大值

              break;

           }

           // 2.从右边依次找数据，找到第一个比参数小的数据

           while (--right >= start && datas[right]>= temp);

           // 3,比较是否出现交叉（left和 right）

           if (left < right) {

              // 4,如果没有交叉，交换左右位置的数据

              int d = datas[left];

              datas[left] = datas[right];

              datas[right] = d;

           }else {

              // 5,如果出现交叉，交换左指针和参照物的值，结束

              int d = datas[left];

              datas[left] = datas[end];

              datas[end] = d;

              break;

           }

       }

       return left;

    }

二分查找:

int binarySearch(int[] a,int value){
        int low = 0;
        int high = a.length-1;
        while(low <= high){
                mid = (low+high)/2; //**
                if (a[mid] == value)
                        return mid;
                else if(a[mid] > value)
                        high = mid-1;
                else
                        low = mid +1;
        }
        return -1;
}

汉诺塔问题:

publicstaticvoid move(int panNum, char a,char b,char c) {

       if (panNum == 1) {

           System.out.println("盘：" + panNum + " 从 " + a +" 柱移动 " + c +" 柱");}else {

           move(panNum - 1, a, c, b);

           System.out.println("盘：" + panNum + " 从 " + a +" 柱移动 " + c +" 柱");

           move(panNum - 1, b, a, c);}}

递归:publicstaticint sum(int number) {

       if (number < 1) {

           thrownew RuntimeException("number must > 0");  }

       if (number == 1) {return 1;} else {

           return number +sum(number - 1);

       }}