蛇形奇偶排序

选一种语言就能看到代码

def snake_cell(k, w):
    y, x = divmod(k, w)
    if y % 2 == 1:
        x = w - 1 - x
    return y * w + x


def snake_odd_even_sort(grid, w, h):
    n = w * h
    for phase in range(n):
        swapped = False
        for k in range(phase % 2, n - 1, 2):
            a = snake_cell(k, w)
            b = snake_cell(k + 1, w)
            if grid[a] > grid[b]:
                grid[a], grid[b] = grid[b], grid[a]
                swapped = True
        if not swapped and phase > 0:
            return

function snakeCell(k, w) {
  const y = Math.floor(k / w);
  const x = y % 2 === 1 ? w - 1 - (k % w) : k % w;
  return y * w + x;
}

function snakeOddEvenSort(grid, w, h) {
  const n = w * h;
  for (let phase = 0; phase < n; phase++) {
    let swapped = false;
    for (let k = phase % 2; k + 1 < n; k += 2) {
      const a = snakeCell(k, w);
      const b = snakeCell(k + 1, w);
      if (grid[a] > grid[b]) {
        [grid[a], grid[b]] = [grid[b], grid[a]];
        swapped = true;
      }
    }
    if (!swapped && phase > 0) return;
  }
}

static int snake_cell(int k, int w) {
    int y = k / w;
    int x = k % w;
    if (y % 2 == 1) x = w - 1 - x;
    return y * w + x;
}

void snake_odd_even_sort(int grid[], int w, int h) {
    int n = w * h;
    for (int phase = 0; phase < n; phase++) {
        int swapped = 0;
        for (int k = phase % 2; k + 1 < n; k += 2) {
            int a = snake_cell(k, w);
            int b = snake_cell(k + 1, w);
            if (grid[a] > grid[b]) {
                int t = grid[a];
                grid[a] = grid[b];
                grid[b] = t;
                swapped = 1;
            }
        }
        if (!swapped && phase > 0) return;
    }
}

static int snake_cell(int k, int w) {
    int y = k / w;
    int x = k % w;
    if (y % 2 == 1) x = w - 1 - x;
    return y * w + x;
}

void snake_odd_even_sort(std::vector<int>& grid, int w, int h) {
    int n = w * h;
    for (int phase = 0; phase < n; phase++) {
        bool swapped = false;
        for (int k = phase % 2; k + 1 < n; k += 2) {
            int a = snake_cell(k, w);
            int b = snake_cell(k + 1, w);
            if (grid[a] > grid[b]) {
                std::swap(grid[a], grid[b]);
                swapped = true;
            }
        }
        if (!swapped && phase > 0) return;
    }
}

static int SnakeCell(int k, int w) {
    int y = k / w;
    int x = k % w;
    if (y % 2 == 1) x = w - 1 - x;
    return y * w + x;
}

static void SnakeOddEvenSort(int[] grid, int w, int h) {
    int n = w * h;
    for (int phase = 0; phase < n; phase++) {
        bool swapped = false;
        for (int k = phase % 2; k + 1 < n; k += 2) {
            int a = SnakeCell(k, w);
            int b = SnakeCell(k + 1, w);
            if (grid[a] > grid[b]) {
                (grid[a], grid[b]) = (grid[b], grid[a]);
                swapped = true;
            }
        }
        if (!swapped && phase > 0) return;
    }
}

static int snakeCell(int k, int w) {
    int y = k / w;
    int x = k % w;
    if (y % 2 == 1) x = w - 1 - x;
    return y * w + x;
}

static void snakeOddEvenSort(int[] grid, int w, int h) {
    int n = w * h;
    for (int phase = 0; phase < n; phase++) {
        boolean swapped = false;
        for (int k = phase % 2; k + 1 < n; k += 2) {
            int a = snakeCell(k, w);
            int b = snakeCell(k + 1, w);
            if (grid[a] > grid[b]) {
                int t = grid[a];
                grid[a] = grid[b];
                grid[b] = t;
                swapped = true;
            }
        }
        if (!swapped && phase > 0) return;
    }
}