Here is my naive attempt:

create table t(
    a integer
);

insert into t values
    (1),
    (null),
    (null),
    (2),
    (3),
    (null),
    (null),
    (4),
    (null);

select
    t.rowid,
    t.a AS have,
    coalesce(t.a,max(t2.a)) AS want
from t
left join t t2
on
    t.a is null and
    t2.rowid < t.rowid and
    t2.a is not null
group by t.rowid
order by t.rowid;

Which outputs this:

rowid  have  wanted
-----  ----  ------
1      1     1
2      NULL  1
3      NULL  1
4      2     2
5      3     3
6      NULL  3
7      NULL  3
8      4     4
9      NULL  4

I'm sure there will be better ways of doing this. I also haven't put any thought into edge cases or assumptions.

For each row, search backwards for a non-null value.

select rowid, a as have,
    (select t2.a from t t2
         where t2.rowid<=t1.rowid and t2.a is not null
         order by rowid desc) as wanted
    from t t1;

Can you fix this when the data is put in the table, instead of trying to fix it when the data is retrieved from the table ?

My reasons are the same ones that Gunter covered: table rows don't have an order. Rows in the table are a 'set' or a 'collection', not a 'sequence'. Referring to a 'previous' or 'last' row doesn't mean anything. According to the specifications for SQL, you can run the same SELECT twice and get two different orders.

You can solve it with a recursive CTE. Below is some sample code.

Here s is a sort key (you can use rowid if you must). Since the recursive CTE needs successive numbers, that is done in the first CTE, adding the numbers n for this purpose.

CREATE TABLE ta( s INTEGER, x INTEGER );

INSERT INTO ta VALUES
    (10,1), (12,null), (15,NULL),
    (20,2),
    (30,3), (33,null), (36,null), (38,null),
    (42,4), (44,null);

SELECT oid, * FROM ta;

WITH RECURSIVE
  tan (oid, n, x) AS (
    SELECT oid, row_number() OVER (ORDER BY s), x
    FROM ta),
  tbb (oid, n, o, x, xx) AS (
    VALUES(NULL,NULL,1,NULL,NULL)
    UNION ALL
    SELECT tan.oid, tan.n, tbb.o+1, tan.x,
      COALESCE(tan.x,tbb.xx)
    FROM tbb
    JOIN tan on(tan.n=tbb.o))
UPDATE ta SET x = xx FROM tbb WHERE ta.oid = tbb.oid;

SELECT oid, * FROM ta;

When this is run in sqlite, the output is as follows:

rowid  s   x
-----  --  -
1      10  1
2      12  ⟂
3      15  ⟂
4      20  2
5      30  3
6      33  ⟂
7      36  ⟂
8      38  ⟂
9      42  4
10     44  ⟂
rowid  s   x
-----  --  -
1      10  1
2      12  1
3      15  1
4      20  2
5      30  3
6      33  3
7      36  3
8      38  3
9      42  4
10     44  4

The following trigger will work more better. There is no point updating any row other than the one that was inserted, and then only if a NULL was provided. Also, it will not work if the last added record is deleted before the next is inserted. This will fix those problems.

CREATE TRIGGER onInsert AFTER INSERT ON t WHEN new.value IS NULL
BEGIN
   UPDATE t
      SET value = (
                     select value
                       from t
                      where _rowid_ < new._rowid_
                   order by _rowid_ desc
                      limit 1
                  )
    WHERE _rowid_ = new._rowid_;
   SELECT RAISE(ABORT, 'value cannot be null')
     FROM t
    WHERE _rowid_ == new._rowid_
      AND value IS NULL;
END;

You could even put in a trigger like this (added the capability to look backwards until it finds a not null value) and after one cycle of your ring buffer all the data will be fixed.

CREATE TRIGGER onInsert AFTER INSERT ON t WHEN new.value IS NULL
BEGIN
   UPDATE t
      SET value = (
                     select value
                       from t
                      where _rowid_ < new._rowid_
                        and value IS NOT NULL
                   order by _rowid_ desc
                      limit 1
                  )
    WHERE _rowid_ = new._rowid_;
   SELECT RAISE(ABORT, 'value cannot be null')
     FROM t
    WHERE _rowid_ == new._rowid_
      AND value IS NULL;
END;