比较运算符 #

fn main() {
    let a = 5;
    let b = 5;
    let c = 10;
    
    println!("{} == {} : {}", a, b, a == b);   // true
    println!("{} == {} : {}", a, c, a == c);   // false
    println!("{} != {} : {}", a, b, a != b);   // false
    println!("{} != {} : {}", a, c, a != c);   // true
}

fn main() {
    let a = 0.1 + 0.2;
    let b = 0.3;
    
    println!("0.1 + 0.2 == 0.3 : {}", a == b);  // false（浮点精度问题）
    
    // 使用近似比较
    let epsilon = 1e-10;
    println!("近似相等: {}", (a - b).abs() < epsilon);
}

fn main() {
    let s1 = "hello";
    let s2 = "hello";
    let s3 = "world";
    
    println!("{} == {} : {}", s1, s2, s1 == s2);  // true
    println!("{} == {} : {}", s1, s3, s1 == s3);  // false
    
    let s4 = String::from("hello");
    println!("{} == {} : {}", s1, s4, s1 == s4);  // true
}

fn main() {
    let a = 5;
    let b = 10;
    
    println!("{} > {} : {}", a, b, a > b);    // false
    println!("{} < {} : {}", a, b, a < b);    // true
    println!("{} >= {} : {}", a, b, a >= b);  // false
    println!("{} <= {} : {}", a, b, a <= b);  // true
}

fn main() {
    let c1 = 'a';
    let c2 = 'z';
    let c3 = '中';
    
    println!("'a' < 'z' : {}", c1 < c2);  // true
    println!("'a' < '中' : {}", c1 < c3); // true（按Unicode码点比较）
}

fn main() {
    let s1 = "apple";
    let s2 = "banana";
    let s3 = "apple";
    
    println!("{} < {} : {}", s1, s2, s1 < s2);  // true（字典序）
    println!("{} <= {} : {}", s1, s3, s1 <= s3);// true
}

#[derive(Debug, PartialEq)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p1 = Point { x: 1, y: 2 };
    let p2 = Point { x: 1, y: 2 };
    let p3 = Point { x: 1, y: 3 };
    
    println!("p1 == p2 : {}", p1 == p2);  // true
    println!("p1 == p3 : {}", p1 == p3);  // false
}

#[derive(Debug)]
struct Person {
    name: String,
    age: u32,
}

impl PartialEq for Person {
    fn eq(&self, other: &Self) -> bool {
        self.name == other.name && self.age == other.age
    }
}

fn main() {
    let p1 = Person { name: String::from("Alice"), age: 30 };
    let p2 = Person { name: String::from("Alice"), age: 30 };
    let p3 = Person { name: String::from("Bob"), age: 30 };
    
    println!("p1 == p2 : {}", p1 == p2);  // true
    println!("p1 == p3 : {}", p1 == p3);  // false
}

#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
struct Score {
    value: u32,
}

fn main() {
    let s1 = Score { value: 100 };
    let s2 = Score { value: 90 };
    let s3 = Score { value: 100 };
    
    println!("s1 > s2 : {}", s1 > s2);    // true
    println!("s1 >= s3 : {}", s1 >= s3);  // true
}

fn main() {
    let x = 5;
    
    // 检查范围
    let in_range = x >= 1 && x <= 10;
    println!("{} 在 1-10 范围内: {}", x, in_range);
    
    // 多个条件
    let valid = x > 0 && x < 10 && x % 2 == 1;
    println!("{} 是有效的奇数: {}", x, valid);
}

fn main() {
    let a = Some(5);
    let b = Some(5);
    let c = Some(10);
    let d: Option<i32> = None;
    
    println!("Some(5) == Some(5) : {}", a == b);  // true
    println!("Some(5) == Some(10) : {}", a == c); // false
    println!("Some(5) == None : {}", a == d);     // false
}

fn main() {
    let a: Result<i32, &str> = Ok(5);
    let b: Result<i32, &str> = Ok(5);
    let c: Result<i32, &str> = Err("error");
    
    println!("Ok(5) == Ok(5) : {}", a == b);  // true
    println!("Ok(5) == Err : {}", a == c);    // false
}

fn main() {
    let v1 = vec![1, 2, 3];
    let v2 = vec![1, 2, 3];
    let v3 = vec![1, 2, 4];
    
    println!("v1 == v2 : {}", v1 == v2);  // true
    println!("v1 == v3 : {}", v1 == v3);  // false
    println!("v1 < v3 : {}", v1 < v3);    // true
}

fn find_min_max(numbers: &[i32]) -> (i32, i32) {
    let mut min = numbers[0];
    let mut max = numbers[0];
    
    for &num in numbers {
        if num < min {
            min = num;
        }
        if num > max {
            max = num;
        }
    }
    
    (min, max)
}

fn main() {
    let numbers = vec![3, 1, 4, 1, 5, 9, 2, 6];
    let (min, max) = find_min_max(&numbers);
    
    println!("最小值: {}, 最大值: {}", min, max);
}

fn main() {
    let mut numbers = vec![3, 1, 4, 1, 5, 9, 2, 6];
    
    numbers.sort();
    println!("升序: {:?}", numbers);
    
    numbers.sort_by(|a, b| b.cmp(a));
    println!("降序: {:?}", numbers);
}

fn binary_search(arr: &[i32], target: i32) -> Option<usize> {
    let mut left = 0;
    let mut right = arr.len();
    
    while left < right {
        let mid = left + (right - left) / 2;
        
        if arr[mid] == target {
            return Some(mid);
        } else if arr[mid] < target {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    
    None
}

fn main() {
    let arr = vec![1, 2, 3, 4, 5, 6, 7, 8, 9];
    
    match binary_search(&arr, 5) {
        Some(index) => println!("找到，索引: {}", index),
        None => println!("未找到"),
    }
}