算法与数据结构2

算法与数据结构02-线性查找和二分查找（队列和栈）

线性查找：顺序查找，速度较慢

package com.kele;

import java.sql.SQLOutput;
import java.util.Arrays;

/**队列: 先进先出
 * @author 12402
 */
public class MyQueue {

    private int[] arr;

    public MyQueue() {
        arr = new int[0];
    }

    // 往队列中添加元素
    public void add(int target){
        int[] newArr = new int[arr.length + 1];
        for (int i = 0; i < arr.length; i++) {
            newArr[i] = arr[i];
        }

        newArr[newArr.length-1] = target;
        arr = newArr;

    }

    // 展示队列元素
    public void show(){
        System.out.println(Arrays.toString(arr));
    }

    // 取出最先静茹的元素
    public int pop(){
        int target = arr[arr.length - 1];
        int[] newArr = new int[arr.length - 1];

        for (int i = 0; i < newArr.length; i++) {
            newArr[i] = arr[i];
        }
        newArr = arr;
        return target;
    }

    // 取出最后进的元素
    public int pop2(){
        int target = arr[0];
        int[] newArr = new int[arr.length - 1];

        for (int i = 0; i < newArr.length; i++) {
            newArr[i] = arr[i];
        }
        newArr = arr;
        return target;
    }

    public boolean isEmpty(){
        return arr.length == 0;
    }
}

二分查找：查询速度较快

package com.kele;

/** 二分法查找
 * @author 12402
 */
public class BinarySearch {

    public static void main(String[] args) {

        // 定义目标数组
        int[] arr = {1,2,3,4,5,6,7,8};

        // 要查找的目标元素
        int target = 5;

        // 查找的起始位置
        int begin = 0;

        // 查找的结束位置
        int end = arr.length-1;

        //中间位置
       // int mid = (arr.length)/2;
        int mid = (begin + end)/2;

        //元素下标
        int index = -1;

        // 循环查找
        while (true){
            // 目标元素等于数组中间元素
            if (arr[mid] == target){
                index = mid;
                break;
            }else {
                // 目标元素小于中间元素
                if (arr[mid] > target) {

                    end = mid - 1;

                    // 目标元素大于中间元素
                } else {
                    begin = mid + 1;
                }

                mid = (begin + end)/2;
            }
        }
        System.out.println("元素下标：" + index);
    }
}

对象数组中的查询（整合）

package com.kele;

import java.util.Arrays;

public class MyArray {

   private int[] arr;

    public MyArray() {
        arr = new int[0];
    }

   // 数组长度
   public int  size(){
       return arr.length;
   }

   public void show(){
       System.out.println(Arrays.toString(arr));
   }

    //数组末尾添加元素
    public void add(int a){

        int[] newArr = new int[arr.length + 1];
        for (int i = 0; i < arr.length; i++) {
            newArr[i] = arr[i];
        }
        newArr[arr.length] = a;
        arr = newArr;
    }

    //删除元素
    public void delete(int index){
        if (index < 0 || index > arr.length - 1){
            throw new RuntimeException("超出数组范围");
        }
        int[] newArr = new int[arr.length -1];
        for (int i = 0; i < newArr.length; i++) {


            if (i < index){
                newArr[i] = arr[i];
            }else {
                newArr[i] = arr[i + 1];
            }
        }
        arr = newArr;
    }

    // 插入元素
    public void insert(int index,int b){
        if (index < 0 || index > arr.length - 1){
            throw new RuntimeException("超出数组范围");
        }

        int[] newArr = new int[arr.length + 1];
        for (int i = 0; i < arr.length; i++) {
            if (i < index){
                newArr[i] = arr[i];
            }else {
                newArr[i + 1] = arr[i];
            }
        }
        newArr[index] = b;
        arr = newArr;
    }

    // 获取指定元素
    public void get(int index){
        if (index < 0 || index > arr.length - 1){
            throw new RuntimeException("超出数组范围");
        }
        int c = arr[index];
        System.out.println(c);
    }

    // 替换指定元素
    public void set(int index,int d){
        if (index < 0 || index > arr.length - 1){
            throw new RuntimeException("超出数组范围");
        }
        arr[index] = d;
    }

    // 线性查找
    public int  search(int target){
      for (int i = 0; i < arr.length; i++) {
          // 在数组中寻找对应的目标元素
          if (arr[i] == target) {
              // 找到目标元素值下标
              return i;
          }
      }
      return -1;
    }

    public int binarySearch(int target){
        // 查找的起始位置
        int begin = 0;

        // 查找的结束位置
        int end = arr.length-1;

        //中间位置
        // int mid = (arr.length)/2;
        int mid = (begin + end)/2;

        // 循环查找
        while (true){

            // 如果没有查找的元素，开始位置大于结束位置
            if (begin >= end){
                return -1;
            }
            // 目标元素等于数组中间元素
            if (arr[mid] == target){
                return mid;
            }else {
                // 目标元素小于中间元素
                if (arr[mid] > target) {

                    end = mid - 1;

                    // 目标元素大于中间元素
                } else {
                    begin = mid + 1;
                }

                mid = (begin + end)/2;
            }
        }
    }
}

栈：先进后出

package com.kele;

import java.util.Arrays;

/** 栈：先进后出
 * @author 12402
 */
public class MyStack {

    private int[] arr;

    public MyStack() {
        arr = new int[0];
    }

    // 压入元素
    public void push(int target){
        int[] newArr = new int[arr.length + 1];
        for (int i = 0; i < arr.length; i++) {
            newArr[i] =  arr[i];
        }
        newArr[arr.length] = target;
        arr = newArr;
    }

    public void show(){
        System.out.println(Arrays.toString(arr));
    }

    // 取出栈顶元素
    public int pop(){
        if (arr.length == 0){
            throw new RuntimeException("栈中没有元素");
        }

        int top = arr[arr.length - 1];
        int[] newArr = new int[arr.length -1];
        for (int i = 0; i < newArr.length; i++) {
            newArr[i] = arr[i];
        }
        arr = newArr;
        return top;

    }

    // 查看栈顶元素
    public int peek(){
        // 只能拿到栈顶元素，无法取出栈顶元素
         return arr[arr.length -1 ];
    }

    public boolean isEmpty(){
        return arr.length == 0;
    }
}

队列

package com.kele;

import java.sql.SQLOutput;
import java.util.Arrays;

/**队列: 先进先出
 * @author 12402
 */
public class MyQueue {

    private int[] arr;

    public MyQueue() {
        arr = new int[0];
    }

    // 往队列中添加元素
    public void add(int target){
        int[] newArr = new int[arr.length + 1];
        for (int i = 0; i < arr.length; i++) {
            newArr[i] = arr[i];
        }

        newArr[newArr.length-1] = target;
        arr = newArr;

    }

    // 展示队列元素
    public void show(){
        System.out.println(Arrays.toString(arr));
    }

    // 取出最先静茹的元素
    public int pop(){
        int target = arr[arr.length - 1];
        int[] newArr = new int[arr.length - 1];

        for (int i = 0; i < newArr.length; i++) {
            newArr[i] = arr[i];
        }
        newArr = arr;
        return target;
    }

    // 取出最后进的元素
    public int pop2(){
        int target = arr[0];
        int[] newArr = new int[arr.length - 1];

        for (int i = 0; i < newArr.length; i++) {
            newArr[i] = arr[i];
        }
        newArr = arr;
        return target;
    }

    public boolean isEmpty(){
        return arr.length == 0;
    }
}

思想

增加元素就是添加一个新数组，长度大于旧数组，然后将旧数组的值赋给新数组，
再将新数组空余的一个位置添加元素，最后将新数组的值赋给旧数组，完成旧数组元
素的增加。

// 往队列中添加元素
   public void add(int target){
       int[] newArr = new int[arr.length + 1];
       for (int i = 0; i < arr.length; i++) {
           newArr[i] = arr[i];
       }

       newArr[newArr.length-1] = target;
       arr = newArr;

   }

删除元素就是添加一个新数组，长度小于旧数组，然后将旧数组的值赋给新数组，
旧数组多的一个元素就会被删除，最后将新数组的值赋给旧数组，完成旧数组元
素的删除。

//删除元素
   public void delete(int index){
       if (index < 0 || index > arr.length - 1){
           throw new RuntimeException("超出数组范围");
       }
       int[] newArr = new int[arr.length -1];
       for (int i = 0; i < newArr.length; i++) {


           if (i < index){
               newArr[i] = arr[i];
           }else {
               newArr[i] = arr[i + 1];
           }
       }
       arr = newArr;
   }

修改数组元素，将修改的值赋给要修改值的数组下标，完成修改

 // 替换指定元素
   public void set(int index,int d){
       if (index < 0 || index > arr.length - 1){
           throw new RuntimeException("超出数组范围");
       }
       arr[index] = d;
   }