Algorytm / pseudo-kod do tworzenia linków przywoławczych?

Kontrolki zazwyczaj pokazują kontrolki dla: P1, Pn, Pc( bieżąca strona), Pc+1, Pc-1. Zmiana ta następuje tylko na obu końcach zakresu stronicowania {Pc (Pn-3)}

• pierwszym krokiem jest oczywiście obliczenie liczby stron:

numPages = ceiling(totalRecords / numPerPage)

• Jeśli masz 4 lub mniej, drop out w tym momencie, ponieważ, zgodnie z powyższymi zasadami, stronicowanie zawsze będzie stałe (P1, P2, Pn-1, Pn), gdzie jeden będzie acutally Pc

• Else, masz trzy "stany"

A. (Pc 1, Pokaż link 'prev' przed P1.

B. (Pc > Pn - 2), więc pokaż Prev, P1, Pn-2, Pn -1, PN, Pokaż następny link, jeśli Pc

C. Pokaż Prev, P1, Pc -1, Pc, Pc +1, PN, Next

Proste jak Pie w pseudo kodzie. Pętle mogą być nieco nieprzyjemne po zaimplementowaniu, ponieważ musisz wykonać kilka iteracji, aby wygenerować linki.

Edytuj: Oczywiście Prev i Next są identyczne jak Pc +/- 1

Cóż, jeśli znasz bieżącą stronę, to dość trywialne jest po prostu odjąć liczbę przez 1 i dodać ją przez 1, a następnie sprawdzić te liczby względem granic i wyświetlać zawsze pierwszą i ostatnią stronę, a następnie, jeśli nie są w kolejności, dodaj elipsy.

A może pytasz o uzyskanie całkowitej liczby stron i określenie bieżącego numeru strony...?

public void PageLinks(int currentPage, int lastPage) {
    if (currentPage > 2) 
        Add('[1]', '...');
    for(int i=Math.Max(1, currentPage-1); i< Math.Min(currentPage+1, lastPage); i++)
        Add('[i]');
    if (currentPage < lastPage-1)
        Add('...', '[lastpage]');
}

LastPage jest obliczany jako matematyka.Sufit(totalRecords/Recordspepage).

Edit: podgląd formatuje kod poprawnie, dlaczego jest zniekształcony? jasne, to tylko pseudokod.... ale jednak....

Oto moje podejście do tworzenia łącza przywoławczego. Następujące kod java to tylko pseudo.

package com.edde;

/**
 * @author Yang Shuai
 */
public class Pager {

    /**
     * This is a method used to display the paging links(pagination or sometimes called pager).
     * The totalPages are the total page you need to display. You can get this value using the
     * formula:
     * 
     *     total_pages = total_records / items_per_page
     * 
     * This methods is just a pseudo-code.
     * 
     * 
     * @param totalPages how many pages you need to display
     * @param currentPage you are in which page now
     */
    public static void printPageLinks(int totalPages, int currentPage) {

        // how many pages to display before and after the current page
        int x = 2;

        // if we just have one page, show nothing
        if (totalPages == 1) {
            return;
        }

        // if we are not at the first page, show the "Prev" button
        if (currentPage > 1) {
            System.out.print("Prev");
        }

        // always display the first page
        if (currentPage == 1) {
            System.out.print("    [1]");
        } else {
            System.out.print("    1");
        }

        // besides the first and last page, how many pages do we need to display?
        int how_many_times = 2 * x + 1;

        // we use the left and right to restrict the range that we need to display
        int left = Math.max(2, currentPage - 2 * x - 1);
        int right = Math.min(totalPages - 1, currentPage + 2 * x + 1);

        // the upper range restricted by left and right are more loosely than we need,
        // so we further restrict this range we need to display
        while (right - left > 2 * x) {
            if (currentPage - left < right - currentPage) {
                right--;
                right = right < currentPage ? currentPage : right;
            } else {
                left++;
                left = left > currentPage ? currentPage : left;
            }
        }

        // do we need display the left "..."
        if (left >= 3) {
            System.out.print("    ...");
        }

        // now display the middle pages, we display how_many_times pages from page left
        for (int i = 1, out = left; i <= how_many_times; i++, out++) {
            // there are some pages we need not to display
            if (out > right) {
                continue;
            }

            // display the actual page
            if (out == currentPage) {
                System.out.print("    [" + out + "]");
            } else {
                System.out.print("    " + out);
            }
        }

        // do we need the right "..."
        if (totalPages - right >= 2) {
            System.out.print("    ...");
        }

        // always display the last page
        if (currentPage == totalPages) {
            System.out.print("    [" + totalPages + "]");
        } else {
            System.out.print("    " + totalPages);
        }

        // if we are not at the last page, then display the "Next" button
        if (currentPage < totalPages) {
            System.out.print("    Next");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        // printPageLinks(50, 3);
        help(500);
    }

    public static void test(int n) {
        for (int i = 1; i <= n; i++) {
            printPageLinks(n, i);
        }
        System.out.println("------------------------------");
    }

    public static void help(int n) {
        for (int i = 1; i <= n; i++) {
            test(i);
        }
    }

    public static void help(int from, int to) {
        for (int i = from; i <= to; i++) {
            test(i);
        }
    }

}

Oto mój algorytm. Działa naprawdę ładnie:

// Input
total_items   // Number of rows, records etc. from db, file or whatever
per_page      // num items per page
page          // current page
visible_pages // number of visible pages

// Calculations
lastPage = ceil(total_items / per_page);
prevPage = page - 1 < 1 ? 0 : page - 1;
nextPage = page + 1 > lastPage ? 0 : page + 1;
halfpages = ceil(visible_pages / 2);
startPage = page - halfpages < 1 ? 1 : page - halfpages;
endPage = startPage + visible_pages - 1;
if(endPage > lastPage) {
    startPage -= endPage - lastPage;
    startPage = startPage < 1 ? 1 : startPage;
    endPage = startPage + visible_pages > lastPage ? lastPage : startPage + visible_pages - 1;
}

// Output
lastPage    // Total number of pages
prevPage    // Previous page number (if 0 there is no prev page)
nextPage    // Next page number (if 0 there is no next page)
startPage   // First visible page
endPage     // Last visible page

Więc możesz zrobić pager taki:

if prevPage
    [1] [prevPage] 
endif

[startPage] ... [endPage] 

if nextPage
    [nextPage] [lastPage] 
endif