Polar code is a new type of channel encoding scheme proposed by Professor E. Ankan in 2008. The polar code is designed based on channel polarization, and is the first constructive encoding scheme that can be proven, through a strict mathematical method, to achieve a channel capacity. The polar code is a type of linear block code. A generator matrix of the polar code is GN, and an encoding process of the polar code isx1N=u1NGN,where u1N=(u1, u2, . . . uN) is an N-bit binary row vector (namely, a code length of u1N is N), x1N is an N-bit encoded row vector, GN is an N×N matrix, and GN=F2⊗(log2(N)). Herein,
            F      2        =          [                                    1                                0                                                1                                1                              ]        ,and F2⊗(log2(N)) is defined as a Kronecker product of a quantity log2 N of matrices F2. For example,
      F    =          [                                    1                                0                                                1                                1                              ]                  F              ⊗        2              =          [                                    1                                0                                0                                0                                                1                                1                                0                                0                                                1                                0                                1                                0                                                1                                1                                1                                1                              ]                  F              ⊗        3              =          [                                    1                                0                                0                                0                                0                                0                                0                                0                                                1                                1                                0                                0                                0                                0                                0                                0                                                1                                0                                1                                0                                0                                0                                0                                0                                                1                                1                                1                                1                                0                                0                                0                                0                                                1                                0                                0                                0                                1                                0                                0                                0                                                1                                1                                0                                0                                1                                1                                0                                0                                                1                                0                                1                                0                                1                                0                                1                                0                                                1                                1                                1                                1                                1                                1                                1                                1                              ]      
In the polar code encoding process, some bits in u1N are used to carry information, and are referred to as information bits. Each bit in u1N has an index, and an index set of the information bits is marked as A. The other bits are set to a fixed value (referred to as fixed bits) pre-agreed on by a receive end (receiving device) and a transmit end (transmitting device), and an index set of these bits is represented by a complementary set Ac of A. Generally, these fixed bits are usually set to 0. Alternatively, a fixed bit sequence may be randomly set as pre-agreed on by the receive end and the transmit end. Therefore, an encoding output of the polar code may be simplified as x1N=uAGN(A). Herein, uA is an information bit set in u1N, and uA is a row vector of a length K, in other words, |A|=K, where |A| represents a quantity of elements in the set A, and K is an information block size. GN(A) is a submatrix obtained from rows in the matrix GN that are corresponding to indexes in the set A, and GN(A) is a K row×N column matrix. A polar code construction process is a process of selecting the set A, and the selection of set A determines polar code performance.
To improve the polar code performance, check precoding is usually performed on information bits before performing the polar encoding. This is called check precoding cascaded polar encoding. There are two common check precoding manners: cyclic redundancy check (CRC) cascaded polar encoding and parity check (PC) cascaded polar encoding. It may be considered that both CRC bits and PC bits are auxiliary bits. Generally, a CRC bit is usually considered as a special information bit, and is placed on a subchannel (bit position) that is more reliable than the information bit, but PC bit position selection has not yet been defined. In the prior art, an auxiliary bit position is usually determined based on reliability or a row weight of each subchannel that is calculated in real time, and this is time-consuming and is not conducive to rapid implementation. The embodiments of the present application provide a solution for rapidly determining an auxiliary bit position, so as to reduce encoding delay or decoding delay.