how to convert edge list to adjacency matrix

I have this code

function adj=edgeL2adjj(e)
    Av = [e; fliplr(e)];
    nodes = unique(Av(:, 1:2)); % get all nodes, sorted
    adj = zeros(numel(nodes));   % initialize adjacency matrix
    % across all edges
    for i=1:size(Av,1)
        adj(nodes==Av(i,1),(nodes==Av(i,2))) = 1;
    end
end

to convert an edge list to an adjacency matrix but if I input u=[8 5;1 4;3 5;6 7] and then I divide u into two set [8 5;1 4], [3 5,6 7] and apply previous code on [3 5;6 7] I will get a 7 x 7 matrix.
but I want a 8 x 8 matrix to any input.

Solution

You have a 7x7 matrix because numel(nodes)=7. Indeed node #2 is not present in u. I suggest you to give this function a second input, that is the maximum number of nodes in your network (in this case, 8) and preallocate the adjacency matrix with such input parameter instead of numel(nodes). Or, alternatively, you can preallocate a zeros() square matrix by giving in input not numel(nodes), but the maximum value in input u. The first option will make your code more robust, the second option will make your code robust as long as the 8-th node is in input u.

Also, there is no need for the fliplr(): if your graph is undirected (that is, the adjacency matrix is symmetric) you can rely on such structure inside the for-loop, without concatenation in Av.

Such function can indeed be simplified as follows:

function adj=edgeL2adjj(e)

adj=zeros(max(max(e)));   % initialize adjacency matrix

% across all edges
for i=1:size(e,1)
    adj(e(i,1),e(i,2))=1;
    adj(e(i,2),e(i,1))=1;
end
end

If the input e is your matrix:

e= [8 5;1 4;3 5;6 7];

such code returns

adj =

     0     0     0     1     0     0     0     0
     0     0     0     0     0     0     0     0
     0     0     0     0     1     0     0     0
     1     0     0     0     0     0     0     0
     0     0     1     0     0     0     0     1
     0     0     0     0     0     0     1     0
     0     0     0     0     0     1     0     0
     0     0     0     0     1     0     0     0

As you can see you simply exploit the input e. The maximum value is 8, so you build a square 8x8 matrix. Also inside the for-loop by swapping the column indices 1 and 2 in e, you automatically take care of the symmetric structure of the adjacency matrix. Finally, this code automatically sort you out in case of missing nodes: indeed, as you can see, the second row and the second column in adj are all-zeros because node #2 is not present in the edge list e.

Note: I do not recommend to split your input edge list. In this manner, you will loose all the global informations regarding your network. Indeed you will have (let's say) two "sub-networks" which you later have to concatenate (in terms of adjacency matrix). That is, if you split e in two sub-matrices, you'll have two adjacency matrices. By taking into account the code as it is now in my answer, the first matrix will be 8x8 whereas the second will be 7x7 because max(max([3 5;6 7]))=7.